import { Logs } from '../vendor/generics/log.js';
import { DataToken } from '../datatoken.js';
import { Event } from '../event.js';
import { Range } from '../range.js';
import { Signal } from '../signal.js';
import { Queue, QueueItem } from '../vendor/generics/queue.js';
import { Interval } from './../interval.js';
import { Position } from './../position.js';
import { Repository, Scanner, ScannerFactory } from './../scanner.js';
import { SearchState, SearchStateFactory } from './searchstate.js';
import { IncrementalSink } from '../incremental.js';
import { Link } from '../vendor/generics/link.js';
import { IndexMap } from '../vendor/generics/indexmap.js';
/**
 * Runs multiple searches across an input stream.
 *
 * Effectively, each input Scanner is a sliding window:
 * For all Scanners which share the same closed index, feed input incrementally.
 *
 * More in server/notes/race-scanner.md
 */
declare class Listener {
    callbacks: IndexMap<any>;
    constructor();
    get length(): number;
    observe(callback: (err: Error, data?: any, cancel?: () => any | void) => any | void): void;
    resolve(val: any): void;
}
declare class Hooks {
    root: {
        beforeAllHooks: Listener;
        afterAllHooks: Listener;
    };
    beforeHooks: Listener;
    afterHooks: Listener;
    beforeGroups: number;
    afterGroups: number;
    constructor();
    addBeforeAllHook(cb: any): void;
    addBeforeHook(cb: any): void;
    addAfterAllHook(cb: any): void;
    addAfterHook(cb: any): void;
    callBeforeHooks(key: any, value: any, ...data: any[]): void;
    callAfterHooks(key: any, value: any, ...data: any[]): void;
}
export declare class Search implements Scanner<string, Range.ReadOutput[]> {
    id: string;
    rootInterval: Interval;
    lastInterval: Interval;
    lastData: DataToken;
    lastObserved: 'EVENT' | 'DATA' | 'NONE';
    stateFactory: SearchStateFactory;
    state: SearchState;
    previous: SearchState[];
    scanner: Scanner<string, Range.ReadOutput[]>;
    count: number;
    buffer: Queue<DataToken>;
    startEvents: Queue<Event>;
    endEvents: Queue<Event>;
    inputFinished: boolean;
    completed: boolean;
    processing: boolean;
    terminal: Signal<Range.ReadOutput[], number>;
    lastInputIndex: number;
    lookaheadClosedIndex: number;
    closedIndex: number;
    table: Repository;
    toReturn: Range.ReadOutput[];
    logs: Logs;
    lookaheadStateFactory: SearchStateFactory;
    lookaheadState: SearchState;
    incremental?: IncrementalSink;
    links: {
        [key: string]: Link;
    };
    hooks: Hooks;
    ancestors: any;
    constructor(initial: string, table: Repository, id: string, incremental?: IncrementalSink);
    print(tabs?: number): string;
    logState(): void;
    complete(): boolean;
    hasData(signal: Signal<string, number>): boolean;
    getReturnValue(): any;
    getTokens(signal: Signal<string, number>): Queue<DataToken>;
    signalBeforeHook(key: any, value: any, ...data: any[]): void;
    signalAfterHook(key: any, value: any, ...data: any[]): void;
    addOutput(data: Event): void;
    clearBuffer(ignore?: boolean): void;
    pushState(name: any): void;
    endState(): void;
    popState(iterations?: number): void;
    transition(): QueueItem<DataToken>;
    startLookahead(lookahead: Event.Start): void;
    processLookahead(lookahead: Event | DataToken): void;
    endLookahead(event: Event): void;
    setStart(position: Position): void;
    findLookaheadStart(result: any, processingState: any, resultItems: any): {
        isProcessing: any;
        resultItems: any;
        result: any;
    };
    findTermination(resultItems: any, processingState: any, bufferItem: any): {
        result: any;
        isProcessing: any;
        bufferItem: any;
    };
    processBuffer(): void;
    shift(signal: Signal<string, number>): Signal<Range.ReadOutput[], number>;
    static factory(initial: string, table: Repository, id: string): ScannerFactory<string, Range.ReadOutput[]>;
}
export {};
//# sourceMappingURL=search.d.ts.map