import { Index, DistinctIndex } from "./indexes";
import { Tracer, TraceNode } from "./trace";
export declare var debug: Function;
export declare function printField(field: ScanField): string | number | null | undefined;
export declare function printFieldArray(fields: ScanField[]): string;
export declare function printPrefix(prefix: Prefix): RawValue[];
export declare function printBlock(block: Block): string;
export declare function maybeReverse(value?: ID): ID | RawValue | undefined;
export declare var ALLOCATION_COUNT: any;
export declare function createHash(place?: string): any;
export declare function createArray(place?: string): never[];
export declare function copyArray(arr: any[], place?: string): any[];
export declare function copyHash(hash: any, place?: string): any;
export declare function concatArray(arr: any[], arr2: any[]): any[];
export declare function moveArray(arr: any[], arr2: any[]): any[];
export declare class Iterator<T> {
    array: T[];
    length: number;
    ix: number;
    push(value: T): void;
    clear(): void;
    reset(): void;
    next(): T | undefined;
    iter(): ReadOnlyIterator<T>;
}
export declare class ReadOnlyIterator<T> extends Iterator<T> {
    constructor(arr: T[], length: number);
    push(value: T): void;
}
/** The union of value types we support in Eve. */
export type RawValue = string | number;
/**  An interned value's ID. */
export type ID = number;
export declare class Interner {
    currentID: number;
    strings: {
        [value: string]: ID | undefined;
    };
    numbers: {
        [value: number]: ID | undefined;
    };
    IDs: RawValue[];
    IDRefCount: number[];
    IDFreeList: number[];
    arenas: {
        [arena: string]: Iterator<ID>;
    };
    constructor();
    _getFreeID(): number;
    reference(id: ID): void;
    intern(value: RawValue): ID;
    get(value: RawValue): ID | undefined;
    reverse(id: ID): RawValue;
    release(id: ID | undefined): void;
    arenaIntern(arenaName: string, value: RawValue): ID;
    releaseArena(arenaName: string): void;
}
export declare var GlobalInterner: Interner;
export type Multiplicity = number;
export type EAVNField = "e" | "a" | "v" | "n";
export declare class Change {
    e: ID;
    a: ID;
    v: ID;
    n: ID;
    transaction: number;
    round: number;
    count: Multiplicity;
    constructor(e: ID, a: ID, v: ID, n: ID, transaction: number, round: number, count: Multiplicity);
    static fromValues(e: any, a: any, v: any, n: any, transaction: number, round: number, count: Multiplicity): Change;
    toString(): string;
    equal(other: Change, withoutNode?: boolean, withoutE?: boolean): boolean;
    reverse(interner?: Interner): RawChange;
    toRawEAV(interner?: Interner): RawEAV;
    clone(): Change;
}
export declare class RemoveChange extends Change {
    toString(): string;
    clone(): RemoveChange;
}
export declare class RemoveVsChange extends RemoveChange {
    toRemoveChanges(context: EvaluationContext, changes: Change[]): void;
    clone(): RemoveVsChange;
}
export declare class RemoveAVsChange extends RemoveVsChange {
    toRemoveChanges(context: EvaluationContext, changes: Change[]): void;
    clone(): RemoveAVsChange;
}
export declare class RawChange {
    e: RawValue;
    a: RawValue;
    v: RawValue;
    n: RawValue;
    transaction: number;
    round: number;
    count: Multiplicity;
    constructor(e: RawValue, a: RawValue, v: RawValue, n: RawValue, transaction: number, round: number, count: Multiplicity);
    toString(): string;
}
export type Prefix = ID[];
export declare class Register {
    offset: number;
    constructor(offset: number);
}
export declare function isRegister(x: any): x is Register;
export declare var IGNORE_REG: null;
export type IgnoreRegister = typeof IGNORE_REG;
export interface Proposal {
    cardinality: number;
    forFields: Iterator<EAVNField>;
    forRegisters: Iterator<Register>;
    proposer: Constraint;
    skip?: boolean;
    info?: any;
}
export type RoundArray = number[];
export declare enum ApplyInputState {
    pass = 0,
    fail = 1,
    none = 2
}
export interface Constraint {
    isInput: boolean;
    toString(): string;
    setup(): void;
    getRegisters(): Register[];
    applyInput(input: Change, prefix: Prefix): ApplyInputState;
    isAffected(input: Change): ApplyInputState;
    propose(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: any[]): Proposal;
    resolveProposal(context: EvaluationContext, prefix: Prefix, proposal: Proposal, transaction: number, round: number, results: any[]): ID[][];
    accept(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, solvingFor: Register[]): boolean;
    acceptInput(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number): boolean;
    getDiffs(context: EvaluationContext, prefix: Prefix): RoundArray;
}
/** A scan field may contain a register, a static interned value, or the IGNORE_REG sentinel value. */
export type ScanField = Register | ID | IgnoreRegister;
/** A resolved value is a scan field that, if it contained a register, now contains the register's resolved value. */
export type ResolvedValue = ID | undefined | IgnoreRegister;
export type ResolvedEAVN = {
    e: ResolvedValue;
    a: ResolvedValue;
    v: ResolvedValue;
    n: ResolvedValue;
};
export declare class EAVN {
    e: ID;
    a: ID;
    v: ID;
    n: ID;
    constructor(e: ID, a: ID, v: ID, n: ID);
}
export type EAV = [ID, ID, ID];
export type RawEAV = [RawValue, RawValue, RawValue];
export type RawEAVC = [RawValue, RawValue, RawValue, number];
export declare class MoveConstraint {
    from: Register | ID;
    to: Register;
    constructor(from: Register | ID, to: Register);
    shouldApplyInput: boolean;
    proposal: Proposal;
    registers: Register[];
    resolved: (ID | undefined)[];
    isInput: boolean;
    isStatic: boolean;
    toString(): string;
    setup(): void;
    resolve(prefix: Prefix): (number | undefined)[];
    getRegisters(): Register[];
    isAffected(input: Change): ApplyInputState;
    applyInput(input: Change, prefix: Prefix): ApplyInputState;
    propose(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: any[]): Proposal;
    resolveProposal(context: EvaluationContext, prefix: Prefix, proposal: Proposal, transaction: number, round: number, results: any[]): ID[][];
    accept(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, solvingFor: Register[]): boolean;
    acceptInput(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number): boolean;
    getDiffs(context: EvaluationContext, prefix: Prefix): RoundArray;
}
/**
 * A scan maps a set of bound variables to unbound variables.
 */
export declare class Scan implements Constraint {
    e: ScanField;
    a: ScanField;
    v: ScanField;
    n: ScanField;
    constructor(e: ScanField, a: ScanField, v: ScanField, n: ScanField);
    protected resolved: ResolvedEAVN;
    protected registers: Register[];
    protected registerLookup: boolean[];
    isInput: boolean;
    proposal: Proposal;
    toString(): string;
    toKey(): string;
    /**
     * Resolve each scan field.
     * The resolved object may contain one of three possible value types:
     * - IGNORE_REG -- this field is entirely ignored by the scan.
     * - undefined -- this field is a register that hasn't been filled in yet.
     *                We'll fill it if possible.
     * - ID -- this field contains a static or already solved value.
     */
    resolve(prefix: Prefix): ResolvedEAVN;
    /**
     * A field is unresolved if it is completely ignored by the scan or
     * is an output of the scan.
     */
    fieldUnresolved(resolved: ResolvedEAVN, key: keyof ResolvedEAVN): boolean;
    /**
     * A field is not a static match if it is ignored, not a static
     * field, or the input value does not match the static value.
     */
    notStaticMatch(input: Change, key: "e" | "a" | "v" | "n"): boolean;
    isAffected(input: Change): ApplyInputState;
    /**
     * Apply new changes that may affect this scan to the prefix to
     * derive only the results affected by this change.  If the change
     * was successfully applied or irrelevant we'll return true. If the
     * change was relevant but invalid (i.e., this scan could not be
     * satisfied due to proposals from previous scans) we'll return
     * false.
     */
    applyInput(input: Change, prefix: Prefix): ApplyInputState;
    propose(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: any[]): Proposal;
    resolveProposal(context: EvaluationContext, prefix: Prefix, proposal: Proposal, transaction: number, round: number, results: any[]): ID[][];
    accept(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, solvingFor: Register[]): boolean;
    acceptInput(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number): boolean;
    setupRegister(field: EAVNField, parts: string[]): void;
    setupIsAffected(): void;
    setupApplyInput(): void;
    setup(): void;
    getRegisters(): Register[];
    getDiffs(context: EvaluationContext, prefix: Prefix): RoundArray;
}
export type ConstraintFieldMap = {
    [name: string]: ScanField;
};
export type ResolvedFields = {
    [fieldName: string]: ResolvedValue;
};
export declare class FunctionConstraint implements Constraint {
    fields: ConstraintFieldMap;
    restFields: (ID | Register)[];
    static registered: {
        [name: string]: typeof FunctionConstraint;
    };
    static register(name: string, klass: typeof FunctionConstraint): void;
    static filter: boolean;
    static variadic: boolean;
    static argNames: string[];
    static returnNames: string[];
    static fetchInfo(name: string): typeof FunctionConstraint;
    static create(name: string, fields: ConstraintFieldMap, restFields?: (ID | Register)[]): FunctionConstraint | undefined;
    constructor(fields: ConstraintFieldMap, restFields: (ID | Register)[]);
    name: string;
    args: {
        [name: string]: string;
    };
    returns: {
        [name: string]: string;
    };
    argNames: string[];
    returnNames: string[];
    apply: (this: FunctionConstraint, ...things: any[]) => undefined | (number | string)[] | (number | string)[][];
    estimate?: (context: EvaluationContext, prefix: Prefix, transaction: number, round: number) => number;
    state?: any;
    multi: boolean;
    isInput: boolean;
    fieldNames: string[];
    proposal: Proposal;
    protected resolved: ResolvedFields;
    protected resolvedRest: (number | undefined)[];
    protected registers: Register[];
    protected registerLookup: boolean[];
    protected applyInputs: (RawValue | RawValue[])[];
    protected applyRestInputs: RawValue[];
    toString(): string;
    setup(): void;
    setupResolve(): void;
    setupResolveRest(): void;
    getRegisters(): Register[];
    /**
     * Similar to `Scan.resolve`, but resolving a map of the function's
     * fields rather than an EAVN.
     */
    resolve(prefix: Prefix): ResolvedFields;
    /**
     * If a function is variadic, we need to resolve its rest fields as well.
     */
    resolveRest(prefix: Prefix): (number | undefined)[];
    isAffected(input: Change): ApplyInputState;
    applyInput(input: Change, prefix: Prefix): ApplyInputState;
    propose(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: any[]): Proposal;
    /**
     * Pack the resolved register values for the functions argument
     * fields into an array.
     */
    packInputs(prefix: Prefix): (RawValue | RawValue[])[];
    unpackOutputs(outputs: RawValue[]): Prefix;
    getResult(prefix: Prefix, outputs: ID[]): Prefix;
    checkResult(prefix: Prefix, outputs: ID[]): boolean;
    resolveProposal(context: EvaluationContext, prefix: Prefix, proposal: Proposal, transaction: number, round: number, results: any[]): ID[][];
    accept(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, solvingFor: Register[]): boolean;
    acceptInput(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number): boolean;
    getDiffs(context: EvaluationContext, prefix: Prefix): RoundArray;
}
export interface FunctionSetup {
    name: string;
    variadic?: boolean;
    args: {
        [argName: string]: string;
    };
    returns: {
        [argName: string]: string;
    };
    apply: (this: FunctionConstraint, ...things: any[]) => undefined | (number | string)[] | (number | string)[][];
    estimate?: (index: Index, prefix: Prefix, transaction: number, round: number) => number;
    initialState?: any;
    multi?: true | false;
}
export interface SingleFunctionSetup extends FunctionSetup {
    apply: (this: FunctionConstraint, ...things: any[]) => undefined | (number | string)[];
    multi?: false;
}
export interface MultiFunctionSetup extends FunctionSetup {
    apply: (this: FunctionConstraint, ...things: any[]) => undefined | (number | string)[][];
    multi?: true;
}
export declare function makeFunction(args: SingleFunctionSetup): void;
export declare function makeMultiFunction(args: MultiFunctionSetup): void;
/**
 * Base class for nodes, the building blocks of blocks.
 */
export declare abstract class Node {
    static NodeID: number;
    ID: number;
    traceType: TraceNode;
    results: Iterator<Prefix>;
    toBranchString(): string;
    /**
     * Evaluate the node in the context of the currently solved prefix,
     * returning a set of valid prefixes to continue the query as
     * results.
     */
    abstract exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
/**
 * The JoinNode implements generic join across multiple constraints.
 * Since our system is incremental, we need to do something slightly
 * fancier than we did in the previous runtime.  For each new change
 * that enters the system, we ask each of our constraints whether they
 * are capable of producing a new result. In the case where a single
 * constraint can, we presolve that constraint and then run the rest
 * normally, limited to only producing results that match the first
 * constraint. However, if multiple constraints might apply the input,
 * we need to run for each *combination* of heads. E.g.:
 *
 * Given a join node with constraints [A, B, C, and D], where A and D
 * can both apply the input, we must combine the results of the
 * following computations to get the full result set:
 *
 * Apply {A} -> Do {B, C, D}
 * Apply {A, D} -> Do {B, C}
 * Apply {D} -> Do {A, B, C}
 *
 * We calculate this using the power set in exec.
 *
 * We then apply each of these combinations by running a genericJoin
 * over the remaining unresolved registers.  We ask each un-applied
 * constraint to propose a register to be solved. If a constraint is
 * capable of resolving one, it returns the set of registers it can
 * resolve and an estimate of the result set's cardinality. Generic
 * Join chooses the cheapest proposal, which the winning constraint
 * then fully computes (or retrieves from cache and returns). Next it
 * asks each other constraint to accept or reject the proposal. If the
 * constraint doesn't apply to the solved registers, it accepts.  If
 * the solution contains results that match the output of the
 * constraint, it also accepts. Otherwise, it must reject the solution
 * and that particular run yields no results.
 */
export declare class JoinNode extends Node {
    constraints: Constraint[];
    traceType: TraceNode;
    isStatic: boolean;
    dormant: boolean;
    registerLength: number;
    registerLookup: boolean[];
    registerArrays: Register[][];
    proposedResultsArrays: ID[][];
    emptyProposal: Proposal;
    inputCount: Multiplicity;
    protected affectedConstraints: Iterator<Constraint>;
    constructor(constraints: Constraint[]);
    toString(): string;
    findAffectedConstraints(input: Change, prefix: Prefix): Iterator<Constraint>;
    applyCombination(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): boolean;
    unapplyConstraint(constraint: Constraint, prefix: Prefix): void;
    presolveCheck(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number): boolean;
    computeMultiplicities(context: EvaluationContext, results: Iterator<Prefix>, prefix: Prefix, currentRound: number, diffs: RoundArray[], diffIndex?: number): Iterator<Prefix>;
    prefixToResults(context: EvaluationContext, constraints: Constraint[], prefix: Prefix, round: number, results: Iterator<Prefix>): void;
    genericJoin(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, roundIx?: number): Iterator<Prefix>;
    downStreamExec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): boolean;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): boolean;
}
export declare class DownstreamJoinNode extends JoinNode {
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): boolean;
}
export declare class NoopJoinNode extends JoinNode {
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): boolean;
}
export declare class WatchNode extends Node {
    e: ID | Register;
    a: ID | Register;
    v: ID | Register;
    n: ID | Register;
    blockId: number;
    traceType: TraceNode;
    constructor(e: ID | Register, a: ID | Register, v: ID | Register, n: ID | Register, blockId: number);
    protected resolved: ResolvedFields;
    resolve: (prefix: Prefix) => ResolvedEAVN;
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, results: Iterator<Prefix>, transaction: Transaction): boolean;
}
export declare class OutputWrapperNode extends Node {
    nodes: OutputNode[];
    traceType: TraceNode;
    constructor(nodes: OutputNode[]);
    toString(): string;
    binds: Iterator<Change>;
    commits: Iterator<Change>;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, results: Iterator<Prefix>, transaction: Transaction): boolean;
}
export interface OutputNode {
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, binds: Iterator<Change>, commits: Iterator<Change>): void;
}
export declare class InsertNode implements OutputNode {
    e: ID | Register;
    a: ID | Register;
    v: ID | Register;
    n: ID | Register;
    multiplier: number;
    resolve: (prefix: Prefix) => ResolvedEAVN;
    constructor(e: ID | Register, a: ID | Register, v: ID | Register, n: ID | Register);
    toString(): string;
    setupRegister(field: EAVNField, parts: string[]): void;
    protected resolved: ResolvedEAVN;
    output(change: Change, binds: Iterator<Change>, commits: Iterator<Change>): void;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, binds: Iterator<Change>, commits: Iterator<Change>): boolean;
}
export declare class CommitInsertNode extends InsertNode {
    toString(): string;
    output(change: Change, binds: Iterator<Change>, commits: Iterator<Change>): void;
}
export declare class RemoveNode extends InsertNode {
    multiplier: number;
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, binds: Iterator<Change>, commits: Iterator<Change>): boolean;
}
export declare class CommitRemoveNode extends CommitInsertNode {
    toString(): string;
    multiplier: number;
    protected _exec: (context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, binds: Iterator<Change>, commits: Iterator<Change>) => boolean;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transactionId: number, round: number, binds: Iterator<Change>, commits: Iterator<Change>): boolean;
}
export declare class LinearFlow extends Node {
    nodes: Node[];
    traceType: TraceNode;
    results: Iterator<Prefix>;
    initialResults: Iterator<Prefix>;
    constructor(nodes: Node[]);
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
export type KeyFunction = (prefix: Prefix) => string;
export declare class IntermediateIndexIterator {
    values: {
        [value: string]: any[];
    };
    valueKeys: string[];
    currentCounts: any[];
    valueIx: number;
    countIx: number;
    round: number;
    count: number;
    minRound: number;
    reset(values: {
        [value: string]: any[];
    }, minRound?: number): this;
    next(): Prefix | undefined;
}
export declare class IntermediateIndex {
    static CreateKeyFunction(registers: Register[]): KeyFunction;
    index: {
        [key: string]: {
            [value: string]: any[];
        };
    };
    iterator: IntermediateIndexIterator;
    insert(key: string, prefix: Prefix): void;
    iter(key: string, round: number): IntermediateIndexIterator | undefined;
    hashPrefix(prefix: Prefix): string;
}
export declare class ZeroingIterator {
    counts: Multiplicity[];
    roundIx: number;
    countSum: number;
    minRound: number;
    count: number;
    reset(counts: Multiplicity[], minRound?: number): this;
    next(): number | undefined;
}
export declare class KeyOnlyIntermediateIndex {
    index: {
        [key: string]: Multiplicity[];
    };
    iterator: ZeroingIterator;
    insert(key: string, prefix: Prefix): void;
    has(key: string): boolean;
    iter(key: string, round: number): ZeroingIterator | undefined;
}
export declare abstract class BinaryFlow extends Node {
    left: Node;
    right: Node;
    traceType: TraceNode;
    constructor(left: Node, right: Node);
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    abstract onLeft(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
    abstract onRight(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
}
export declare class BinaryJoinRight extends BinaryFlow {
    left: Node;
    right: Node;
    keyRegisters: Register[];
    registersToMerge: Register[];
    leftIndex: IntermediateIndex;
    rightIndex: IntermediateIndex;
    keyFunc: KeyFunction;
    constructor(left: Node, right: Node, keyRegisters: Register[], registersToMerge: Register[]);
    _nodeName: string;
    toString(): string;
    toBranchString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    merge(left: Prefix, right: Prefix): boolean;
    onLeft(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
    onRight(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
}
export declare class AntiJoin extends BinaryFlow {
    left: Node;
    right: Node;
    keyRegisters: Register[];
    traceType: TraceNode;
    leftIndex: IntermediateIndex;
    rightIndex: KeyOnlyIntermediateIndex;
    distinct: DistinctIndex;
    keyFunc: KeyFunction;
    constructor(left: Node, right: Node, keyRegisters: Register[]);
    toString(): string;
    toBranchString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    onLeft(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
    onRight(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
}
export declare class AntiJoinPresolvedRight extends AntiJoin {
    toString(): string;
    toBranchString(): string;
    traceType: TraceNode;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
export declare class UnionFlow extends Node {
    left: Node;
    keyRegisters: Register[][];
    registersToMerge: Register[];
    extraOuterJoins: Register[];
    traceType: TraceNode;
    branches: BinaryJoinRight[];
    emptyResults: Iterator<Prefix>;
    constructor(left: Node, branches: Node[], keyRegisters: Register[][], registersToMerge: Register[], extraOuterJoins: Register[]);
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
export declare class ChooseFlow extends Node {
    left: Node;
    keyRegisters: Register[][];
    registersToMerge: Register[];
    extraOuterJoins: Register[];
    traceType: TraceNode;
    leftResults: Iterator<Prefix>;
    emptyResults: Iterator<Prefix>;
    branches: (BinaryJoinRight | AntiJoinPresolvedRight)[];
    constructor(left: Node, initialBranches: Node[], keyRegisters: Register[][], registersToMerge: Register[], extraOuterJoins: Register[]);
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
export declare class MergeAggregateFlow extends BinaryJoinRight {
    _nodeName: string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
}
export declare class AggregateOuterLookup extends BinaryFlow {
    left: Node;
    right: Node;
    keyRegisters: Register[];
    _nodeName: string;
    traceType: TraceNode;
    keyFunc: KeyFunction;
    leftIndex: KeyOnlyIntermediateIndex;
    rightIndex: IntermediateIndex;
    constructor(left: Node, right: Node, keyRegisters: Register[]);
    toString(): string;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    onLeft(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
    onRight(context: EvaluationContext, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>): void;
}
export declare abstract class AggregateNode extends Node {
    groupRegisters: Register[];
    projectRegisters: Register[];
    inputs: (ID | Register)[];
    resultRegisters: Register[];
    abstract name: string;
    traceType: TraceNode;
    groupKey: Function;
    projectKey: Function;
    groups: {
        [group: string]: {
            result: any[];
            [projection: string]: Multiplicity[];
        };
    };
    resolved: RawValue[];
    registerLookup: boolean[];
    constructor(groupRegisters: Register[], projectRegisters: Register[], inputs: (ID | Register)[], resultRegisters: Register[]);
    toString(): string;
    groupPrefix(group: string, prefix: Prefix): number;
    getResultPrefix(prefix: Prefix, result: ID, count: Multiplicity): Prefix;
    resolve(prefix: Prefix): RawValue[];
    stateToResult(state: any): ID;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    abstract add(state: any, resolved: RawValue[]): any;
    abstract remove(state: any, resolved: RawValue[]): any;
    abstract getResult(state: any): RawValue;
    abstract newResultState(): any;
}
export declare abstract class SortNode extends Node {
    groupRegisters: Register[];
    projectRegisters: Register[];
    directions: (ID | Register)[];
    resultRegisters: Register[];
    name: string;
    traceType: TraceNode;
    groupKey: Function;
    projectKey: Function;
    groups: {
        [group: string]: {
            result: any[];
            [projection: string]: Multiplicity[];
        };
    };
    resolved: ID[];
    resolvedDirections: RawValue[];
    sortRegisters: Register[];
    constructor(groupRegisters: Register[], projectRegisters: Register[], directions: (ID | Register)[], resultRegisters: Register[]);
    groupPrefix(group: string, prefix: Prefix): number;
    resolve(prefix: Prefix): ID[];
    isGreater(a: Prefix, b: Prefix): string | false;
    prefixEqual(a: Prefix, b: Prefix): boolean;
    exec(context: EvaluationContext, input: Change, prefix: Prefix, transaction: number, round: number, results: Iterator<Prefix>, changes: Transaction): boolean;
    resultPrefix(prefix: Prefix, outOffset: number, pos: number, round: number, count: Multiplicity): any[];
    add: (state: any, resolved: ID[], round: number, results: Iterator<Prefix>) => any;
    remove: (state: any, resolved: ID[], round: number, results: Iterator<Prefix>) => any;
    newResultState(): any;
}
export declare class Block {
    name: string;
    nodes: Node[];
    totalRegisters: number;
    constructor(name: string, nodes: Node[], totalRegisters: number);
    results: Iterator<Prefix>;
    initial: Prefix;
    toString(): string;
    exec(context: EvaluationContext, input: Change, transaction: Transaction): boolean;
}
export declare class EvaluationContext {
    index: Index;
    distinctIndex: DistinctIndex;
    intermediates: {
        [key: string]: IntermediateIndex;
    };
    exportIndex: {
        [beav: string]: number;
    };
    tracer: Tracer;
    constructor(index: Index);
}
export type ExportHandler = (blockChanges: {
    [id: number]: Change[] | undefined;
}) => void;
export declare class Transaction {
    context: EvaluationContext;
    transaction: number;
    blocks: Block[];
    protected exportHandler?: ExportHandler | undefined;
    round: number;
    changes: Change[];
    lastFrame: number;
    protected outputs: Iterator<Change>;
    protected roundChanges: Change[][];
    protected frameCommits: Change[];
    protected framePartialCommits: RemoveVsChange[];
    protected exportedChanges: {
        [blockId: number]: Change[];
    };
    constructor(context: EvaluationContext, transaction: number, blocks: Block[], exportHandler?: ExportHandler | undefined);
    output(context: EvaluationContext, change: Change): void;
    commit(context: EvaluationContext, change: Change): void;
    export(context: EvaluationContext, blockId: number, change: Change): void;
    protected prepareRound(context: EvaluationContext, changeIx: number): void;
    protected collapseCommits(changes: Change[], results: Change[]): Change[];
    protected collapseMultiplicity(changes: Change[], results: Change[], createNew?: boolean): Change[];
    exec(context: EvaluationContext): void;
}
export declare class BlockChangeTransaction extends Transaction {
    context: EvaluationContext;
    transaction: number;
    added: Block[];
    removed: Block[];
    blocks: Block[];
    protected exportHandler?: ExportHandler | undefined;
    constructor(context: EvaluationContext, transaction: number, added: Block[], removed: Block[], blocks: Block[], exportHandler?: ExportHandler | undefined);
    exec(context: EvaluationContext): void;
}