// Copyright (C) 2018-2026 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#pragma once

#include "openvino/runtime/file_handle.hpp"
#include "openvino/runtime/intel_npu/properties.hpp"

namespace ov {
namespace intel_npu {
/**
 * @brief
 * Type: bool
 * Set this option to true to utilize NPUW extension
 * Default value: false
 */
static constexpr ov::Property<bool> use_npuw{"NPU_USE_NPUW"};

namespace npuw {
/**
 * @brief
 * Type: std::string
 * Device list to try in order.
 * Possible values: Comma-separated list of devices. E.g., "NPU,GPU,CPU".
 * Default value: "NPU,CPU"
 */
static constexpr ov::Property<std::string> devices{"NPUW_DEVICES"};

/**
 * @brief
 * Type: std::string.
 * Force the specific subgraph to specific device. The device must be present in the NPUW_DEVICES list.
 * Possible values: Comma-separated "Subgraph index:OpenVINO device name" pairs, "last" keyword can be
 * used for last subgraph, e.g. "0:CPU,1:NPU,last:CPU".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> submodel_device{"NPUW_SUBMODEL_DEVICE"};

/**
 * @brief
 * Type: std::string.
 * Specify bank name to utilize for a particular model.
 * Possible values: any std::string as a name.
 * Default value: empty.
 */
static constexpr ov::Property<std::string> weights_bank{"NPUW_WEIGHTS_BANK"};

/**
 * @brief
 * Type: std::string.
 * Specify device name for weights bank which is used to allocate memory.
 * Default value: "".
 */
static constexpr ov::Property<std::string> weights_bank_alloc{"NPUW_WEIGHTS_BANK_ALLOC"};

/**
 * @brief
 * Type: ov::FileHandleProvider.
 * Callback function to get file handle for weights (cross-platform).
 * The callback takes no arguments and returns a platform-specific file handle.
 * On Linux/Unix: returns int (file descriptor)
 * On Windows: returns void* (HANDLE)
 * This is useful for scenarios where file access needs to be controlled externally,
 * such as Android content providers or restricted file access scenarios.
 * Default value: nullptr.
 */
static constexpr ov::Property<ov::FileHandleProvider> weights_handle_provider{"NPUW_WEIGHTS_HANDLE_PROVIDER"};

/**
 * @brief
 * Type: std::string.
 * Specify a directory where to store cached submodels.
 * Default value: empty.
 */
static constexpr ov::Property<std::string> cache_dir{"NPUW_CACHE_DIR"};

namespace partitioning {
namespace online {
/**
 * @brief
 * Type: std::string.
 * Specify which partitioning pipeline to run.
 * Possible values: "NONE", "INIT", "JUST", "REP", "REG", "COMPUTE", "SPATIAL".
 * Default value: "REG".
 */
static constexpr ov::Property<std::string> pipeline{"NPUW_ONLINE_PIPELINE"};

/**
 * @brief
 * Type: std::string.
 * Forbids operation(s) and/or predefined pattern(s) to compile and run on a
 * specified device. Only compatible with online partitioning.
 * Possible values: comma-separated list of operations slash device, e.g.
 *                  "Op:Select/NPU,P:RMSNorm/NPU".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> avoid{"NPUW_ONLINE_AVOID"};

/**
 * @brief
 * Type: std::string.
 * Isolates predefined pattern(s) to compile and run separately from other isolated tags and no tags.
 * Only compatible with online partitioning.
 * Possible values: comma-separated list of layer or pattern name slash tag, e.g.
 *                  "Op:Select/compute2,P:DQMatMulGQ/compute,P:DQMatMulCW/compute,P:RMSNorm/compute".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> isolate{"NPUW_ONLINE_ISOLATE"};

/**
 * @brief
 * Type: std::string.
 * Make a specific tag introduced via NPUW_ONLINE_ISOLATE a non-foldable one.
 * Only compatible with online partitioning.
 * Possible values: comma-separated list of tags, e.g.
 *                  "compute,compute2".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> nofold{"NPUW_ONLINE_NO_FOLD"};

/**
 * @brief
 * Type: std::size_t.
 * Lower boundary of partition graph size the plugin can generate.
 * Used to control fusion term criteria in online partitioning.
 * Only compatible with online partitioning.
 * Possible values: Integer >= 10.
 * Default value: 10.
 */
static constexpr ov::Property<std::size_t> min_size{"NPUW_ONLINE_MIN_SIZE"};

/**
 * @brief
 * Type: std::size_t.
 * Sets the minimum number of repeating groups of the same pattern the plugin will keep in the partitioning.
 * Used to control fusion term criteria in online partitioning.
 * Only compatible with online partitioning.
 * Possible values: Integer > 0.
 * Default value: 5.
 */
static constexpr ov::Property<std::size_t> keep_blocks{"NPUW_ONLINE_KEEP_BLOCKS"};

/**
 * @brief
 * Type: std::size_t.
 * Sets the minimum group size (in layers) within the same pattern the plugin will keep in the partitioning.
 * Used to control fusion term criteria in online partitioning.
 * Only compatible with online partitioning.
 * Possible values: Integer > 0.
 * Default value: 10.
 */
static constexpr ov::Property<std::size_t> keep_block_size{"NPUW_ONLINE_KEEP_BLOCK_SIZE"};

/**
 * @brief
 * Type: std::string.
 * Dump online partitioning to the specified file.
 * This partitioning can be reused via NPUW_PLAN property later.
 * Possible values: Path to .xml file.
 * Default value: empty.
 */
static constexpr ov::Property<std::string> dump_plan{"NPUW_ONLINE_DUMP_PLAN"};
}  // namespace online

/**
 * @brief
 * Type: std::string.
 * Set plan file to use by offline partitioning.
 * Possible values: Path to .xml file.
 * Default value: empty.
 */
static constexpr ov::Property<std::string> plan{"NPUW_PLAN"};

/**
 * @brief
 * Type: bool.
 * Perform function call folding if there are repeating blocks in the graph.
 * Default value: false.
 */
static constexpr ov::Property<bool> fold{"NPUW_FOLD"};

/**
 * @brief
 * Type: bool.
 * Cut-off weights from repeating blocks, but don't do folding.
 * Decompression cut-off may still happen. Conflicts with NPUW_FOLD.
 * Default value: false.
 */
static constexpr ov::Property<bool> cwai{"NPUW_CWAI"};

/**
 * @brief
 * Type: bool.
 * Apply dynamic quantization transformations at the plugin side.
 * Default value: false.
 */
static constexpr ov::Property<bool> dyn_quant{"NPUW_DQ"};

/**
 * @brief
 * Type: bool.
 * Apply the full DQ transformation pipeline in the plugin.
 * Default value: true.
 */
static constexpr ov::Property<bool> dyn_quant_full{"NPUW_DQ_FULL"};

/**
 * @brief
 * Type: string.
 * Identify and merge parallel MatMuls over dimension(s) specified.
 * When set to YES, applies transformation for all dimensions.
 * Works with FOLD enabled only.
 * Set to NO or pass empty value to disable the option.
 * Default value: 2.
 */
static constexpr ov::Property<std::string> par_matmul_merge_dims{"NPUW_PMM"};

/**
 * @brief
 * Type: bool.
 * Add Slice before the last MatMul reducing output's dimention.
 * Default value: false.
 */
static constexpr ov::Property<bool> slice_out{"NPUW_SLICE_OUT"};

/**
 * @brief
 * Type: boolean.
 * Enable spatial execution for selected subgraphs. Requires COMPUTE isolation.
 * Default value: false
 */
static constexpr ov::Property<bool> spatial{"NPUW_SPATIAL"};

/**
 * @brief
 * Type: std::size_t.
 * Submission size for the spatial execution.
 * Default value: 128
 */
static constexpr ov::Property<std::size_t> spatial_nway{"NPUW_SPATIAL_NWAY"};

/**
 * @brief
 * Type: boolean.
 * Enable dynamic submission for spatial subgraphs. Requires SPATIAL pipeline to be selected.
 * Default value: true
 */
static constexpr ov::Property<bool> spatial_dyn{"NPUW_SPATIAL_DYN"};

/**
 * @brief
 * Type: uint64_t.
 * MoE expert model compilation strategy for prefill stage token chunking.
 *
 * When set to 0 (default): Compiles multiple expert models with different chunk sizes
 * {16, 32, 64, 128, 256} for dynamic chunk selection at runtime. This provides optimal
 * performance by selecting the best chunk size based on remaining tokens.
 *
 * When set to a specific value (e.g., 128, 256): Compiles only a single expert model
 * with the specified fixed chunk size. This reduces compilation time and memory usage but
 * may not be optimal for all token counts.
 *
 * The chunk size should be a power of two for best hardware utilization.
 * Note: This only affects prefill stage (multi-token inference). Decoding stage (single token)
 * always uses a dedicated model regardless of this setting.
 *
 * Default value: 0 (dynamic multi-model compilation).
 */
static constexpr ov::Property<uint64_t> moe_token_chunk_size{"NPUW_MOE_TOKEN_CHUNK_SIZE"};

/**
 * @brief Configure MoE request pool size per layer for caching expert configurations.
 *
 * Controls the number of pre-allocated inference requests per MoE layer to cache
 * different expert combinations. Using LRU eviction when pool is full.
 * Setting to 0 disables the MoE request cache entirely.
 *
 * Type: std::size_t.
 * Default value: 8 (cache up to 8 expert configurations per layer).
 */
static constexpr ov::Property<std::size_t> moe_pool_size{"NPUW_MOE_POOL_SIZE"};

/**
 * @brief
 * Type: std::string.
 * Select attention optimization mode when attention block detected.
 * Possible values: "DYNAMIC", "STATIC", "PYRAMID", "HFA"
 * Default value: "STATIC"
 */
static constexpr ov::Property<std::string> attn{"NPUW_ATTN"};

/**
 * @brief
 * Type: boolean.
 * Enable dynamic dispatch for the attention block, if detected
 * Default value: true
 */
static constexpr ov::Property<bool> attn_dyn{"NPUW_ATTN_DYN"};

/**
 * @brief
 * Type: boolean.
 * Force no-copy mode for the attention block, if detected
 * Default value: false
 */
static constexpr ov::Property<bool> attn_no_copy{"NPUW_ATTN_NO_COPY"};

/**
 * @brief
 * Type: boolean
 * Force subgraph interconnect tensors to f16 precision if those are in f32
 * Default value: false
 */
static constexpr ov::Property<bool> f16_interconnect{"NPUW_F16IC"};

/**
 * @brief
 * Type: boolean
 * When applicable, do embedding gather on host.
 * Default value: true.
 */
static constexpr ov::Property<bool> host_gather{"NPUW_HOST_GATHER"};

/**
 * @brief
 * Type: std::string.
 * Promotional data type for weights decompression. Works only with function "NPUW_FOLD"ing.
 * Possible values: "i8", "f16"
 * Default value: empty.
 */
static constexpr ov::Property<std::string> dcoff_type{"NPUW_DCOFF_TYPE"};

/**
 * @brief
 * Type: bool.
 * Include weights scaling into the decompression procedure (and exclude it from function bodies).
 * Works only with function "NPUW_FOLD"ing.
 * Default value: false.
 */
static constexpr ov::Property<bool> dcoff_with_scale{"NPUW_DCOFF_SCALE"};

/**
 * @brief
 * Type: bool.
 * Every subgraph will be turned into a function.
 * Warning: May cause performance issues!
 * Default value: false.
 */
static constexpr ov::Property<bool> funcall_for_all{"NPUW_FUNCALL_FOR_ALL"};
}  // namespace partitioning

/**
 * @brief
 * Type: bool.
 * Employ parallel subgraph compilation. Disabled by default due to instabilities.
 * Default value: false.
 */
static constexpr ov::Property<bool> parallel_compilation{"NPUW_PARALLEL_COMPILE"};

/**
 * @brief
 * Type: bool.
 * Pipeline execution of functions (repeating blocks) and their prologues
 * (e.g., where weights decompression may happen).
 * Default value: false.
 */
static constexpr ov::Property<bool> funcall_async{"NPUW_FUNCALL_ASYNC"};

/**
 * @brief
 * Type: boolean
 * Create individual infer requests for partitiongs, even repeating.
 * Default value: false.
 */
static constexpr ov::Property<bool> unfold_ireqs{"NPUW_UNFOLD_IREQS"};

/**
 * @brief
 * Type: boolean
 * Fallback in case of runtime failure
 * Default value: true.
 */
static constexpr ov::Property<bool> fallback_exec{"NPUW_FALLBACK_EXEC"};

namespace accuracy {
/**
 * @brief
 * Type: bool.
 * Enable accuracy check for inference to make infer requests
 * tolerant to accuracy fails
 * Default value: false.
 */
static constexpr ov::Property<bool> check{"NPUW_ACC_CHECK"};

/**
 * @brief
 * Type: double.
 * Threshold for accuracy validators, to indicate that metric
 * returns successfull comparison.
 * Possible values: Double floating-point value from 0.0 to 1.0.
 * Default value: 0.1.
 */
static constexpr ov::Property<double> threshold{"NPUW_ACC_THRESH"};

/**
 * @brief
 * Type: std::string.
 * Reference device, giving accurate results for given model(s).
 * Possible values: device name, e.g. "CPU".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> reference_device{"NPUW_ACC_DEVICE"};
}  // namespace accuracy

namespace dump {
/**
 * @brief
 * Type: std::string.
 * Dump the whole model in its original form (as plugin gets it, before any partitioning is done).
 * Default value: false.
 */
static constexpr ov::Property<bool> full{"NPUW_DUMP_FULL"};

/**
 * @brief
 * Type: std::string.
 * Dump the specified subgraph(s) in OpenVINO IR form in the current directory.
 * Possible values: Comma-separated list of subgraph indices ("last" can be used
 * for dumping last subgraph without specifying it by specific index), "YES" for
 * all subgraphs, "MIN" for representative subgraph subset (all non-repeated and
 * one instance of repeated block), "NO" or just empty value to turn option off.
 * E.g. "0,1" or "0,1,last" or "YES".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> subgraphs{"NPUW_DUMP_SUBS"};

/**
 * @brief
 * Type: std::string.
 * Directory path for dumping subgraph models (.xml).
 * Default behavior: when this property is not set or set to an empty string,
 * the current working directory is used. Any non-empty value is interpreted
 * as a directory path.
 */
static constexpr ov::Property<std::string> subgraphs_dir{"NPUW_DUMP_SUBS_DIR"};

/**
 * @brief
 * Type: std::string.
 * Dump subgraph on disk if a compilation failure happens.
 * Possible values: Comma-separated list of subgraph indices ("last" can be used
 * for dumping last subgraph) or "YES" for all subgraphs, "MIN" for representative
 * subgraph subset, "NO" or just empty value to turn option off. E.g. "0,1" or
 * "0,1,last" or "YES".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> subgraphs_on_fail{"NPUW_DUMP_SUBS_ON_FAIL"};

/**
 * @brief
 * Type: std::string.
 * Dump input & output tensors for subgraph(s).
 * Possible values: Comma-separated list of subgraph indices ("last" can be used for
 * last subgraph) or "YES" for all subgraphs, "MIN" for representative subgraph subset,
 * "NO" or just empty value to turn option off. E.g. "0,1" or "0,1,last" or "YES".
 * Default value: empty.
 */
static constexpr ov::Property<std::string> inputs_outputs{"NPUW_DUMP_IO"};

/**
 * @brief
 * Type: std::string.
 * Dump input & output tensors for subgraph(s) for every iteration.
 * WARNING: may exhaust the disk space quickly.
 * Default value: false.
 */
static constexpr ov::Property<std::string> io_iters{"NPUW_DUMP_IO_ITERS"};
}  // namespace dump

namespace llm {
/**
 * @brief
 * Type: bool.
 * Tell NPUW that you want to pass dynamic stateful LLM model.
 * Default value: false.
 */
static constexpr ov::Property<bool> enabled{"NPUW_LLM"};

/**
 * @brief
 * FIXME: Should be removed.
 * Type: uint32_t.
 * Dimension of the batch in input tensor shape.
 * Default value: 0.
 */
static constexpr ov::Property<uint32_t> batch_dim{"NPUW_LLM_BATCH_DIM"};

/**
 * @brief
 * FIXME: Should be removed.
 * Type: uint32_t.
 * Dimension of KV-Cache size in input tensor shape.
 * Default value: 2.
 */
static constexpr ov::Property<uint32_t> seq_len_dim{"NPUW_LLM_SEQ_LEN_DIM"};

/**
 * @brief
 * Type: uint32_t.
 * Desirable max prompt length.
 * Default value: 1024.
 */
static constexpr ov::Property<uint32_t> max_prompt_len{"NPUW_LLM_MAX_PROMPT_LEN"};

/**
+ * @brief
+ * Type: uint32_t.
+ * Desirable max input token length for generation.
+ * Default value: 1.
+ */
static constexpr ov::Property<uint32_t> max_generation_token_len{"NPUW_LLM_MAX_GENERATION_TOKEN_LEN"};

/**
 * @brief
 * Type: uint32_t.
 * Desirable min response length.
 * Default value: 128.
 */
static constexpr ov::Property<uint32_t> min_response_len{"NPUW_LLM_MIN_RESPONSE_LEN"};

/**
 * @brief
 * Type: uint32_t.
 * Desirable max LoRA rank.
 * Default value: 32.
 */
static constexpr ov::Property<uint32_t> max_lora_rank{"NPUW_LLM_MAX_LORA_RANK"};

/**
 * @brief
 * FIXME: Should be removed.
 * Type: bool.
 * Tell NPUW to apply values transpose optimization for the model.
 * Default value: false.
 */
static constexpr ov::Property<bool> optimize_v_tensors{"NPUW_LLM_OPTIMIZE_V_TENSORS"};

/**
 * @brief
 * Type: bool.
 * Tell NPUW to apply fp8 static quantisation pass from openvino low_precision library
 * Default value: false.
 */
static constexpr ov::Property<bool> optimize_fp8{"NPUW_LLM_OPTIMIZE_FP8"};

/**
 * @brief
 * Type: boolean
 * Substitute part of the RoPE with compile-time precalculation in higher precision
 * Default value: true.
 */
static constexpr ov::Property<bool> cache_rope{"NPUW_LLM_CACHE_ROPE"};

/**
 * @brief
 * Type: ::intel_npu::npuw::llm::MoEHint
 * Specify MoE (Mixture of Experts) implementation strategy for prefill stage
 * Possible values: DENSE, HOST_ROUTED, DEVICE_ROUTED
 * Default value: HOST_ROUTED (recommended for prefill to avoid NPU-unfriendly operations)
 */
static constexpr ov::Property<std::string> prefill_moe_hint{"NPUW_LLM_PREFILL_MOE_HINT"};

/**
 * @brief
 * Type: ::intel_npu::npuw::llm::MoEHint
 * Specify MoE (Mixture of Experts) implementation strategy for generate/decoding stage
 * Possible values: DENSE, HOST_ROUTED, DEVICE_ROUTED
 * Default value: HOST_ROUTED (DEVICE_ROUTED recommended for better decoding performance)
 */
static constexpr ov::Property<std::string> generate_moe_hint{"NPUW_LLM_GENERATE_MOE_HINT"};

/**
 * @brief
 * Type: boolean
 * Enable multiple generate model variants with different static shapes (1K, 2K, 4K, 8K stepping).
 * When enabled, multiple generate models will be compiled and the appropriate one will be
 * selected at runtime based on the required KV cache size.
 * Default value: false.
 */
static constexpr ov::Property<bool> generate_pyramid{"NPUW_LLM_GENERATE_PYRAMID"};

/**
 * @brief
 * Type: uint64_t.
 * Prompt chunk size for chunk prefill.
 * The chunk size should be a power of two.
 * Chunk prefill feature is disabled in case the value is 0.
 * Default value: 1024.
 */
static constexpr ov::Property<uint64_t> prefill_chunk_size{"NPUW_LLM_PREFILL_CHUNK_SIZE"};

/**
 * @brief
 * Type: bool.
 * This toggle enables the prefix caching feature.
 * When activated, it stores the prefilled key-value pairs (KV) for current prompts in the cache during each
 * conversation round.
 * In subsequent rounds, if the prompt's KV is found in the cache, it allows skipping the prefill for certain tokens,
 * thereby enhancing the latency of the first token.
 * Default value: false.
 */
static constexpr ov::Property<uint64_t> enable_prefix_caching{"NPUW_LLM_ENABLE_PREFIX_CACHING"};

/**
 * @brief
 * Type: uint64_t.
 * Prefilled KV tensors are cached in blocks when prefix caching is enabled.
 * This value describes the number of tokens in each block.
 * This value should be not greater than prefill_chunk_size.
 * Default value: 256.
 */
static constexpr ov::Property<uint64_t> prefix_caching_block_size{"NPUW_LLM_PREFIX_CACHING_BLOCK_SIZE"};

/**
 * @brief
 * Type: uint64_t.
 * Prefilled KV tensors are cached in blocks when prefix caching is enabled.
 * This value describes the maximum number of blocks in cache.
 * Default value: 128.
 */
static constexpr ov::Property<uint64_t> prefix_caching_max_num_blocks{"NPUW_LLM_PREFIX_CACHING_MAX_NUM_BLOCKS"};

/**
 * @brief
 * Type: std::string.
 * Hint for prefill stage. NPUW will use optimal configuration based on the passed preference via hint.
 * Passing this hint with "NPUW_LLM_PREFILL_CONFIG" will generate a error.
 * Possible values: "DYNAMIC", "STATIC".
 * Default value: "DYNAMIC".
 */
static constexpr ov::Property<std::string> prefill_hint{"NPUW_LLM_PREFILL_HINT"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Configuration for compilation/execution of prefill model. If specified, it will override default
 * config, prepared by NPUW specifically for this model.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> prefill_config{"NPUW_LLM_PREFILL_CONFIG"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Additional configuration for compilation/execution of prefill model. If specified, it
 * will be appended to the default configuration, prepared by NPUW.
 * For duplicated options, preference will be given to values from given map.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> additional_prefill_config{"++NPUW_LLM_PREFILL_CONFIG"};

/**
 * @brief
 * Type: std::string.
 * Hint for the attention handling in prefill stage. NPUW will use optimal configuration based on the passed preference
 * via hint. Possible values: "DYNAMIC", "STATIC". Default value: "STATIC".
 */
static constexpr ov::Property<std::string> prefill_attn_hint{"NPUW_LLM_PREFILL_ATTENTION_HINT"};

/**
 * @brief
 * Type: std::string.
 * Hint for generation stage. NPUW will use optimal configuration based on the passed preference via hint.
 * Passing this hint with "NPUW_LLM_GENERATE_CONFIG" will generate a error.
 * Possible values: "FAST_COMPILE", "BEST_PERF".
 * Default value: "FAST_COMPILE".
 */
static constexpr ov::Property<std::string> generate_hint{"NPUW_LLM_GENERATE_HINT"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Configuration for compilation/execution of generate model. If specified, it will override default
 * config, prepared by NPUW specifically for this model.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> generate_config{"NPUW_LLM_GENERATE_CONFIG"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Configuration for compilation/execution of generate model. If specified, it
 * will be appended to the default configuration, prepared by NPUW.
 * For duplicated options, preference will be given to values from given map.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> additional_generate_config{"++NPUW_LLM_GENERATE_CONFIG"};

/**
 * @brief
 * Type: std::string.
 * Hint for the attention handling in generate stage. NPUW will use optimal configuration based on the passed preference
 * via hint. Possible values: "DYNAMIC", "STATIC". Default value: "STATIC".
 */
static constexpr ov::Property<std::string> generate_attn_hint{"NPUW_LLM_GENERATE_ATTENTION_HINT"};

/**
 * @brief
 * Type: bool.
 * Tell NPUW to separate LM head into the 3rd model, that will be shared between
 * prefill and generate.
 * Default value: true.
 */
static constexpr ov::Property<bool> shared_lm_head{"NPUW_LLM_SHARED_HEAD"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Configuration for compilation/execution of shared LM head model. If specified, it will override
 * default config, prepared by NPUW specifically for this model.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> shared_lm_head_config{"NPUW_LLM_SHARED_HEAD_CONFIG"};

/**
 * @brief
 * Type: ov::AnyMap.
 * Configuration for compilation/execution of shared LM head model. If specified, it
 * will be appended to the default configuration, prepared by NPUW.
 * For duplicated options, preference will be given to values from given map.
 *
 * NOTE: !! Write-only !!
 */
static constexpr ov::Property<ov::AnyMap> additional_shared_lm_head_config{"++NPUW_LLM_SHARED_HEAD_CONFIG"};
}  // namespace llm

namespace whisper {
/**
 * @brief
 * Type: bool.
 * Tell NPUW that you want to pass Whisper model.
 * Default value: false.
 */
static constexpr ov::Property<bool> enabled{"NPUW_WHISPER"};
}  // namespace whisper

namespace eagle {
/**
 * @brief
 * Type: bool.
 * Tell NPUW that you want to pass Eagle3 model for speculative decoding.
 * Default value: false.
 */
static constexpr ov::Property<bool> enabled{"NPUW_EAGLE"};
}  // namespace eagle

namespace text_embed {
/**
 * @brief
 * Type: bool.
 * Tell NPUW that you want to pass text-embedding model.
 * Default value: false.
 */
static constexpr ov::Property<bool> enabled{"NPUW_TEXT_EMBED"};

}  // namespace text_embed

namespace kokoro {
/**
 * @brief
 * Type: bool
 * Set this option to true to utilize Kokoro pipeline
 * Default value: false
 */
static constexpr ov::Property<bool> enabled{"NPUW_KOKORO"};

/**
 * @brief
 * Type: size_t (uint64_t)
 * Set the block size for Kokoro pipeline
 * Default value: 200
 */
static constexpr ov::Property<uint64_t> block_size{"NPUW_KOKORO_BLOCK_SIZE"};

/**
 * @brief
 * Type: size_t (uint64_t)
 * Set the overlap size for Kokoro pipeline
 * Default value: 20
 */
static constexpr ov::Property<uint64_t> overlap_size{"NPUW_KOKORO_OVERLAP_SIZE"};
}  // namespace kokoro

}  // namespace npuw
}  // namespace intel_npu
}  // namespace ov
