import _m0 from 'protobufjs/minimal';
export declare const protobufPackage = "yandex.cloud.ai.assistants.v1.searchindex";
/** Normalization strategy for relevance scores from different indices */
export declare enum NormalizationStrategy {
    NORMALIZATION_STRATEGY_UNSPECIFIED = 0,
    /** MIN_MAX - https://en.wikipedia.org/wiki/Feature_scaling#Rescaling_(min-max_normalization) */
    MIN_MAX = 1,
    /** L2 - https://en.wikipedia.org/wiki/Cosine_similarity#L2-normalized_Euclidean_distance */
    L2 = 2,
    UNRECOGNIZED = -1
}
export declare function normalizationStrategyFromJSON(object: any): NormalizationStrategy;
export declare function normalizationStrategyToJSON(object: NormalizationStrategy): string;
/** Defines a chunking strategy where chunks are created with a fixed maximum chunk size and an overlap between consecutive chunks. */
export interface StaticChunkingStrategy {
    /**
     * The maximum number of tokens allowed in a single chunk.
     * Constraints: must be within the range [100, 2048].
     * Default value: 800
     */
    maxChunkSizeTokens: number;
    /**
     * The number of tokens that should overlap between consecutive chunks.
     * This allows for some context from the previous chunk to be included in the next chunk.
     * Constraints: must be less than or equal to half of `max_chunk_size_tokens`.
     * Default value: 400
     */
    chunkOverlapTokens: number;
}
/**
 * Defines a general strategy for chunking text into smaller segments.
 * Currently, only StaticChunkingStrategy is supported.
 */
export interface ChunkingStrategy {
    staticStrategy?: StaticChunkingStrategy | undefined;
}
export interface MeanCombinationStrategy {
    /** Technique for averaging relevance scores from different indices. Default is ARITHMETIC */
    meanEvaluationTechnique: MeanCombinationStrategy_MeanEvaluationTechnique;
    /**
     * Weights used for evaluating the weighted mean of relevance scores. The sum of the values must equal 1.0
     * If not provided, all scores are given equal weight
     */
    weights: number[];
}
export declare enum MeanCombinationStrategy_MeanEvaluationTechnique {
    MEAN_EVALUATION_TECHNIQUE_UNSPECIFIED = 0,
    /** ARITHMETIC - https://en.wikipedia.org/wiki/Arithmetic_mean */
    ARITHMETIC = 1,
    /** GEOMETRIC - https://en.wikipedia.org/wiki/Geometric_mean */
    GEOMETRIC = 2,
    /** HARMONIC - https://en.wikipedia.org/wiki/Harmonic_mean */
    HARMONIC = 3,
    UNRECOGNIZED = -1
}
export declare function meanCombinationStrategy_MeanEvaluationTechniqueFromJSON(object: any): MeanCombinationStrategy_MeanEvaluationTechnique;
export declare function meanCombinationStrategy_MeanEvaluationTechniqueToJSON(object: MeanCombinationStrategy_MeanEvaluationTechnique): string;
/** https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf */
export interface ReciprocalRankFusionCombinationStrategy {
    /** The parameter k for RRFscore. Default is 60 */
    k?: number;
}
/** Combination strategy for merging rankings from different indices */
export interface CombinationStrategy {
    meanCombination?: MeanCombinationStrategy | undefined;
    rrfCombination?: ReciprocalRankFusionCombinationStrategy | undefined;
}
/**
 * Configuration for the NgramTokenizer, which splits text into overlapping character sequences (n-grams) of specified lengths.
 *
 * Example:
 * Input text: `hello`
 * min_gram = 2, max_gram = 3
 *
 * Generated tokens:
 * * For n = 2 (2-character n-grams): `he`, `el`, `ll`, `lo`
 * * For n = 3 (3-character n-grams): `hel`, `ell`, `llo`
 *
 * Final tokens: `[he, el, ll, lo, hel, ell, llo]`
 */
export interface NgramTokenizer {
    /** Minimum length of characters in a gram. Defaults to 3 */
    minGram?: number;
    /** Maximum length of characters in a gram. Defaults to 4 */
    maxGram?: number;
}
/**
 * A standard tokenizer that splits text on word boundaries and removes punctuation.
 * It follows the Unicode Text Segmentation rules as specified in Unicode Standard Annex #29.
 *
 * Example:
 * Input text: `Hello, world! How are you?`
 * Output tokens: `[Hello, world, How, are, you]`
 */
export interface StandardTokenizer {
}
/** A standard analyzer that uses StandardTokenizer. */
export interface StandardAnalyzer {
}
/**
 * A specialized analyzer that uses Yandex's lemmatization technology to reduce words to their base forms.
 * Particularly effective for Russian and other Slavic languages, handling their complex morphology.
 * For more information, see:
 * https://yandex.cloud/en/docs/tutorials/dataplatform/opensearch-yandex-lemmer
 */
export interface YandexLemmerAnalyzer {
}
export declare const StaticChunkingStrategy: {
    encode(message: StaticChunkingStrategy, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): StaticChunkingStrategy;
    fromJSON(object: any): StaticChunkingStrategy;
    toJSON(message: StaticChunkingStrategy): unknown;
    fromPartial<I extends {
        maxChunkSizeTokens?: number | undefined;
        chunkOverlapTokens?: number | undefined;
    } & {
        maxChunkSizeTokens?: number | undefined;
        chunkOverlapTokens?: number | undefined;
    } & Record<Exclude<keyof I, keyof StaticChunkingStrategy>, never>>(object: I): StaticChunkingStrategy;
};
export declare const ChunkingStrategy: {
    encode(message: ChunkingStrategy, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ChunkingStrategy;
    fromJSON(object: any): ChunkingStrategy;
    toJSON(message: ChunkingStrategy): unknown;
    fromPartial<I extends {
        staticStrategy?: {
            maxChunkSizeTokens?: number | undefined;
            chunkOverlapTokens?: number | undefined;
        } | undefined;
    } & {
        staticStrategy?: ({
            maxChunkSizeTokens?: number | undefined;
            chunkOverlapTokens?: number | undefined;
        } & {
            maxChunkSizeTokens?: number | undefined;
            chunkOverlapTokens?: number | undefined;
        } & Record<Exclude<keyof I["staticStrategy"], keyof StaticChunkingStrategy>, never>) | undefined;
    } & Record<Exclude<keyof I, "staticStrategy">, never>>(object: I): ChunkingStrategy;
};
export declare const MeanCombinationStrategy: {
    encode(message: MeanCombinationStrategy, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MeanCombinationStrategy;
    fromJSON(object: any): MeanCombinationStrategy;
    toJSON(message: MeanCombinationStrategy): unknown;
    fromPartial<I extends {
        meanEvaluationTechnique?: MeanCombinationStrategy_MeanEvaluationTechnique | undefined;
        weights?: number[] | undefined;
    } & {
        meanEvaluationTechnique?: MeanCombinationStrategy_MeanEvaluationTechnique | undefined;
        weights?: (number[] & number[] & Record<Exclude<keyof I["weights"], keyof number[]>, never>) | undefined;
    } & Record<Exclude<keyof I, keyof MeanCombinationStrategy>, never>>(object: I): MeanCombinationStrategy;
};
export declare const ReciprocalRankFusionCombinationStrategy: {
    encode(message: ReciprocalRankFusionCombinationStrategy, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ReciprocalRankFusionCombinationStrategy;
    fromJSON(object: any): ReciprocalRankFusionCombinationStrategy;
    toJSON(message: ReciprocalRankFusionCombinationStrategy): unknown;
    fromPartial<I extends {
        k?: number | undefined;
    } & {
        k?: number | undefined;
    } & Record<Exclude<keyof I, "k">, never>>(object: I): ReciprocalRankFusionCombinationStrategy;
};
export declare const CombinationStrategy: {
    encode(message: CombinationStrategy, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CombinationStrategy;
    fromJSON(object: any): CombinationStrategy;
    toJSON(message: CombinationStrategy): unknown;
    fromPartial<I extends {
        meanCombination?: {
            meanEvaluationTechnique?: MeanCombinationStrategy_MeanEvaluationTechnique | undefined;
            weights?: number[] | undefined;
        } | undefined;
        rrfCombination?: {
            k?: number | undefined;
        } | undefined;
    } & {
        meanCombination?: ({
            meanEvaluationTechnique?: MeanCombinationStrategy_MeanEvaluationTechnique | undefined;
            weights?: number[] | undefined;
        } & {
            meanEvaluationTechnique?: MeanCombinationStrategy_MeanEvaluationTechnique | undefined;
            weights?: (number[] & number[] & Record<Exclude<keyof I["meanCombination"]["weights"], keyof number[]>, never>) | undefined;
        } & Record<Exclude<keyof I["meanCombination"], keyof MeanCombinationStrategy>, never>) | undefined;
        rrfCombination?: ({
            k?: number | undefined;
        } & {
            k?: number | undefined;
        } & Record<Exclude<keyof I["rrfCombination"], "k">, never>) | undefined;
    } & Record<Exclude<keyof I, keyof CombinationStrategy>, never>>(object: I): CombinationStrategy;
};
export declare const NgramTokenizer: {
    encode(message: NgramTokenizer, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): NgramTokenizer;
    fromJSON(object: any): NgramTokenizer;
    toJSON(message: NgramTokenizer): unknown;
    fromPartial<I extends {
        minGram?: number | undefined;
        maxGram?: number | undefined;
    } & {
        minGram?: number | undefined;
        maxGram?: number | undefined;
    } & Record<Exclude<keyof I, keyof NgramTokenizer>, never>>(object: I): NgramTokenizer;
};
export declare const StandardTokenizer: {
    encode(_: StandardTokenizer, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): StandardTokenizer;
    fromJSON(_: any): StandardTokenizer;
    toJSON(_: StandardTokenizer): unknown;
    fromPartial<I extends {} & {} & Record<Exclude<keyof I, never>, never>>(_: I): StandardTokenizer;
};
export declare const StandardAnalyzer: {
    encode(_: StandardAnalyzer, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): StandardAnalyzer;
    fromJSON(_: any): StandardAnalyzer;
    toJSON(_: StandardAnalyzer): unknown;
    fromPartial<I extends {} & {} & Record<Exclude<keyof I, never>, never>>(_: I): StandardAnalyzer;
};
export declare const YandexLemmerAnalyzer: {
    encode(_: YandexLemmerAnalyzer, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): YandexLemmerAnalyzer;
    fromJSON(_: any): YandexLemmerAnalyzer;
    toJSON(_: YandexLemmerAnalyzer): unknown;
    fromPartial<I extends {} & {} & Record<Exclude<keyof I, never>, never>>(_: I): YandexLemmerAnalyzer;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
export {};