import type { EncodedQuadTerms, PatternTerm, QuadPatternTerms } from '../PatternTerm';
import type { NestedMapActual } from './RdfStoreIndexNestedMap';
/**
 * Something that can determine the keys within a map that match a quoted triple pattern.
 */
export interface IQuotedPatternKeysProvider<TE, TV> {
    getQuotedPatternKeys: (map: NestedMapActual<TE, TV>, term: PatternTerm) => IterableIterator<TE>;
}
/**
 * Iterates over the encoded quads of a nested-map index that match a quad pattern.
 *
 * This is written as an explicit state machine rather than as a generator function.
 * A generator saves and restores its whole frame on every `next()` call, which for a
 * four-level nested loop costs several times more than advancing four iterators by hand.
 * Lookups that produce many results spend most of their time in exactly this loop,
 * so that difference dominates them.
 */
export declare class RdfStoreIndexNestedMapIterator<TE, TV> implements IterableIterator<EncodedQuadTerms<TE>> {
    private readonly ids;
    private readonly terms;
    /**
     * Only set for indexes that support quoted triple patterns,
     * in which case the pattern terms instead of the encoded ids determine the keys to visit.
     */
    private readonly quotedProvider;
    private readonly quoted;
    private readonly map0;
    private map1;
    private map2;
    private map3;
    private iterator0;
    private iterator1;
    private iterator2;
    private iterator3;
    private key0;
    private key1;
    private key2;
    constructor(nestedMap: NestedMapActual<TE, TV>, ids: EncodedQuadTerms<TE | undefined>, terms: QuadPatternTerms, quotedProvider?: IQuotedPatternKeysProvider<TE, TV>);
    /**
     * Determine the keys to visit within the given map at the given level.
     *
     * This is invoked once per visited parent entry, not once per produced result.
     *
     * @param level The nesting level of the given map.
     * @param map The map to determine the keys of.
     */
    private keysAt;
    [Symbol.iterator](): IterableIterator<EncodedQuadTerms<TE>>;
    next(): IteratorResult<EncodedQuadTerms<TE>>;
    /**
     * Stop iterating, and release the references that are held into the index.
     */
    return(): IteratorResult<EncodedQuadTerms<TE>>;
}
/**
 * An iterator over exactly one encoded quad.
 *
 * Fully defined patterns are a single membership check, so they get this instead of the
 * four-level state machine above.
 */
export declare class RdfStoreIndexSingleQuadIterator<TE> implements IterableIterator<EncodedQuadTerms<TE>> {
    private quad;
    constructor(quad: EncodedQuadTerms<TE>);
    [Symbol.iterator](): IterableIterator<EncodedQuadTerms<TE>>;
    next(): IteratorResult<EncodedQuadTerms<TE>>;
}
/**
 * A shared iterator over no encoded quads at all, for patterns without any match.
 *
 * An exhausted array iterator stays exhausted, so a single instance can be handed out for all of them.
 */
export declare const EMPTY_QUAD_ITERATOR: IterableIterator<any>;