import type { ITermDictionary } from '../dictionary/ITermDictionary';
import type { IRdfStoreOptions } from '../IRdfStoreOptions';
import type { QuadPatternTerms, QuadTerms, EncodedQuadTerms } from '../PatternTerm';
import type { IRdfStoreIndex } from './IRdfStoreIndex';
/**
 * An RDF store index that is implemented using nested records.
 */
export declare class RdfStoreIndexNestedRecord<TE extends number, TV> implements IRdfStoreIndex<TE, TV> {
    protected readonly dictionary: ITermDictionary<TE>;
    protected readonly nestedRecords: NestedRecordActual<TE>;
    readonly features: {
        quotedTripleFiltering: boolean;
    };
    constructor(options: IRdfStoreOptions<TE>);
    set(terms: EncodedQuadTerms<TE>, value: TV): boolean;
    remove(terms: EncodedQuadTerms<TE>): boolean;
    get(key: QuadTerms): TV | undefined;
    getEncoded(ids: EncodedQuadTerms<TE>): TV | undefined;
    /**
     * Check if all four pattern terms are plain (non-quoted) defined terms,
     * in which case the pattern can be resolved by a straight chain of record lookups.
     * @param terms The pattern terms.
     */
    protected isExactPattern(terms: QuadPatternTerms): boolean;
    /**
     * Resolve a fully defined pattern by directly walking down the nested records.
     * @param ids The encoded pattern terms.
     * @return boolean If the quad is present in this index.
     */
    protected hasExact(ids: EncodedQuadTerms<TE | undefined>): boolean;
    find(terms: QuadPatternTerms): IterableIterator<QuadTerms>;
    findEncoded(ids: EncodedQuadTerms<TE | undefined>, _terms: QuadPatternTerms): IterableIterator<EncodedQuadTerms<TE>>;
    protected existsPath(depth: number, endDepth: number, map: NestedRecordActual<TE>, filterTerms?: (TE | undefined)[]): boolean;
    protected findTermsInner(depth: number, endDepth: number, map: NestedRecordActual<TE>, matchTerms: boolean[], partialResult: TE[], filterTerms?: (TE | undefined)[]): IterableIterator<TE[]>;
    findTerms(matchTerms: boolean[], filterTerms?: (TE | undefined)[]): IterableIterator<TE[]>;
    count(terms: QuadPatternTerms): number;
    protected countTermsInner(depth: number, endDepth: number, map: NestedRecordActual<TE>, matchTerms: boolean[], filterTerms?: (TE | undefined)[]): number;
    countTerms(matchTerms: boolean[], filterTerms?: (TE | undefined)[]): number;
}
export type NestedRecord<TE extends string | number | symbol> = NestedRecordActual<TE> | true;
export type NestedRecordActual<TE extends string | number | symbol> = Record<TE, Record<TE, Record<TE, Record<TE, any>>>>;