import { IndexClass as IndexClass_2 } from '../main';
import * as v from 'valibot';

declare type ContentRange = v.InferOutput<typeof ContentRange_v>;

declare const ContentRange_v: v.ObjectSchema<{
    readonly id: v.NumberSchema<undefined>;
    readonly path: v.StringSchema<undefined>;
    readonly start: v.NumberSchema<undefined>;
    readonly end: v.NumberSchema<undefined>;
}, undefined>;

export declare function createIndex<T>(index_class: IndexClass, contents: unknown[], opt?: IndexOpt): StaticSeekIndexRoot<SearchIndex<T>> | StaticSeekError;

export declare function createIndexFromObject<T>(index: StaticSeekIndexRoot<T>): StaticSeekIndexRoot<SearchIndex<T>> | StaticSeekError;

export declare function createSearchFn(url: string, callback?: SearchFnCallback): SearchFn;

export declare class GPULinearIndex extends LinearIndex {
    private mutex;
    private device;
    private gpu_buffers;
    private gpu_pipeline;
    private gpu_bind_group;
    private readonly num_result;
    private gpuStorageRead;
    private gpuStorageWrite;
    private gpuStorageReadWrite;
    private gpuUniform;
    private gpuCopy;
    private gpuPipeline;
    private initGPU;
    search(env: SearchEnv, keyword: string[]): Promise<SearchResult[]>;
    private gpuSearch;
}

export declare const HybridTrieBigramInvertedIndex: IndexClass_2;

export declare type IndexClass = new (index?: any) => SearchIndex<any>;

export declare type IndexOpt = {
    key_fields?: Path[];
    search_targets?: Path[];
    distance?: number;
    weights?: [Path, number][];
};

export declare function indexToObject<T>(index: StaticSeekIndexRoot<SearchIndex<T>>): StaticSeekIndexRoot<T>;

export declare class LinearIndex implements SearchIndex<LinearIndexEntry> {
    index_entry: LinearIndexEntry;
    u32_content: Uint32Array;
    constructor(index?: LinearIndexEntry);
    setToIndex(id: number, path: Path, str: string[]): void;
    setDocumentLength(_id: number, _path: Path, _length: number): void;
    addKey(id: number, key: Record<string, unknown>): void;
    fixIndex(): void;
    search(env: SearchEnv, keyword: string[]): Promise<SearchResult[]>;
    protected mergeResults(raw_result: [number, number][]): [number, number][];
    protected createSearchResult(poses: [number, number][], keyword: string, env: SearchEnv): SearchResult[];
    private allIndexOf;
    protected getReference(pos: number): ContentRange;
}

declare type LinearIndexEntry = v.InferOutput<typeof LinearIndexEntry_v>;

declare const LinearIndexEntry_v: v.ObjectSchema<{
    readonly key: v.ArraySchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
    readonly content: v.StringSchema<undefined>;
    readonly content_length: v.NumberSchema<undefined>;
    readonly num_id: v.NumberSchema<undefined>;
    readonly toc: v.ArraySchema<v.ObjectSchema<{
        readonly id: v.NumberSchema<undefined>;
        readonly path: v.StringSchema<undefined>;
        readonly start: v.NumberSchema<undefined>;
        readonly end: v.NumberSchema<undefined>;
    }, undefined>, undefined>;
}, undefined>;

export declare type Path = string;

export declare type Reference = {
    token: string;
    path: Path;
    pos?: number;
    wordaround?: string;
    keyword_range?: [number, number];
    distance: number;
};

export declare function search<T>(index: StaticSeekIndexRoot<SearchIndex<T>>, query: string): Promise<SearchResult[] | StaticSeekError>;

declare type SearchEnv = v.InferOutput<typeof SearchEnv_v>;

declare const SearchEnv_v: v.ObjectSchema<{
    readonly search_targets: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
    readonly field_names: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
    readonly weights: v.ArraySchema<v.TupleSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
    readonly distance: v.NumberSchema<undefined>;
}, undefined>;

export declare type SearchFn = (query: string) => SearchFnResult;

export declare type SearchFnCallback = (isLoading: boolean) => void;

export declare type SearchFnResult = Promise<SearchResult[] | StaticSeekError>;

declare interface SearchIndex<T> {
    index_entry: T;
    setToIndex(id: number, path: Path, str: string[]): void;
    setDocumentLength(id: number, path: Path, length: number): void;
    addKey(id: number, key: Record<string, unknown>): void;
    fixIndex(): void;
    search(env: SearchEnv, keyword: string[]): Promise<SearchResult[]>;
}

export declare type SearchResult = {
    id: number;
    key: Record<string, unknown>;
    score: number;
    refs: Reference[];
};

export declare class StaticSeekError extends Error {
}

export declare type StaticSeekIndex = StaticSeekIndexRoot<SearchIndex<unknown>>;

export declare type StaticSeekIndexObject = StaticSeekIndexRoot<unknown>;

declare type StaticSeekIndexRoot<T> = {
    version: string;
    type: string;
    env: SearchEnv;
    index_entry: T;
};

export { }