import { DeepKeyOf } from '../lib/odata';
import { AnalyzedDocument, AnalyzedValue } from './analyzerService';
import { SchemaService } from './schema';
export interface ScoringFnIdentity<T extends object> {
    fieldName: DeepKeyOf<T>;
}
export interface ScoringFnApplication {
    boost: number;
    interpolation?: 'constant' | 'linear' | 'quadratic' | 'logarithmic';
}
export interface ScoringMagnitudeFn extends ScoringFnApplication {
    type: 'magnitude';
    magnitude: {
        boostingRangeStart: number;
        boostingRangeEnd: number;
        constantBoostBeyondRange?: boolean;
    };
}
export interface ScoringFreshnessFn extends ScoringFnApplication {
    type: 'freshness';
    freshness: {
        boostingDuration: string;
    };
}
export interface ScoringDistanceFn extends ScoringFnApplication {
    type: 'distance';
    distance: {
        referencePointParameter: string;
        boostingDistance: number;
    };
}
export interface ScoringTagFn extends ScoringFnApplication {
    type: 'tag';
    tag: {
        tagsParameter: string;
    };
}
export declare type ScoringFn = ScoringMagnitudeFn | ScoringFreshnessFn | ScoringDistanceFn | ScoringTagFn;
export declare type IdentifiedScoringFn<T extends object> = ScoringFnIdentity<T> & ScoringFn;
export interface ScoringProfile<T extends object> {
    name: string;
    text?: {
        weights: Partial<Record<DeepKeyOf<T>, number>>;
    };
    functions?: IdentifiedScoringFn<T>[];
    functionAggregation?: 'sum' | 'average' | 'minimum' | 'maximum' | 'firstMatching';
}
export declare type ScoringParams = Record<string, string[]>;
export declare type ScoringBases = {
    key: string;
    score: number;
}[];
export declare type ScoringStrategy = (value: AnalyzedValue) => number;
export declare type ScoringStrategies = (document: AnalyzedDocument, bases: ScoringBases) => number;
export declare type RawScoringStrategy = (params: ScoringParams) => ScoringStrategy;
export declare type RawScoringStrategies = (params: ScoringParams) => ScoringStrategies;
export declare class Scorer<T extends object> {
    readonly schemaService: SchemaService<T>;
    readonly profiles: ScoringProfile<T>[];
    readonly defaultProfile: string | null;
    strategies: Record<string, RawScoringStrategies>;
    defaultStrategy: RawScoringStrategies | null;
    static readonly nullStrategy: ScoringStrategies;
    constructor(schemaService: SchemaService<T>, profiles: ScoringProfile<T>[], defaultProfile: string | null);
    getScoringStrategies(profile: string | null, parameters: string[] | null): ScoringStrategies;
}