import { RawValue, RawEAV, RawEAVC, Register, ID } from "./runtime";
import * as Runtime from "./runtime";
import * as indexes from "./indexes";
import { Watcher, Exporter, DiffConsumer, ObjectConsumer, RawRecord } from "../watchers/watcher";
import "./stdlib";
export type Value = Reference | RawValue;
export type ProxyReference = any;
export type Owner = any;
export declare class Reference {
    __context: ReferenceContext;
    __owner?: Owner | undefined;
    static ReferenceID: number;
    static create(context: ReferenceContext, value?: Owner | RawValue): Reference;
    __ID: number;
    __forceRegister: boolean;
    constructor(__context: ReferenceContext, __owner?: Owner | undefined);
    add(attrMap: {
        [attr: string]: Value | Value[];
    }): Reference;
    add(attribute: Value, value: Value | Value[]): Reference;
    remove(attribute?: Value, value?: Value | Value[]): Reference;
    toString(): string;
    __proxy(): any;
}
export declare class ReferenceContext {
    parent?: ReferenceContext | undefined;
    static IDs: number;
    static stack: ReferenceContext[];
    static push(context: ReferenceContext): void;
    static pop(): void;
    ID: number;
    flow: LinearFlow;
    references: Reference[];
    equalities: Value[][];
    forcedMoves: Value[][];
    referenceValues: (Register | RawValue)[];
    totalRegisters: number;
    maxRegisters: number;
    constructor(parent?: ReferenceContext | undefined, flow?: LinearFlow);
    register(ref: Reference): void;
    equality(a: Value, b: Value): void;
    getActive(): ReferenceContext;
    owns(ref: Reference): boolean;
    getValue(ref: Reference | RawValue, orGenerateRegister?: boolean): Register | RawValue;
    interned(ref: Reference | RawValue): Register | ID;
    maybeInterned(ref: Reference | RawValue | undefined): Register | ID | undefined;
    selectReference(refIds: any, ref: Reference, ref2: Reference): Reference;
    unify(): void;
    getMoves(): Move[];
    getInputReferences(): Reference[];
    getInputRegisters(): Register[];
    updateMaxRegisters(maybeMax: number): void;
    assignRegisters(): void;
}
export type Node = Record | Insert | Fn | Not | Choose | Union | Aggregate | Lookup | Move;
export type LinearFlowFunction = (self: LinearFlow) => (Value | Value[]);
export type RecordAttributes = {
    [key: string]: Value | Value[];
};
export type FlowRecordArg = string | RecordAttributes;
export declare class FlowLevel {
    records: Record[];
    lookups: Lookup[];
    functions: Fn[];
    aggregates: Aggregate[];
    inserts: Insert[];
    nots: Not[];
    chooses: Choose[];
    unions: Union[];
    moves: Move[];
    collect(node: Node): void;
    findReference(node: any): Record | undefined;
    toConstraints(injections: Node[]): (Record | Fn | Lookup)[];
    compile(nodes: Runtime.Node[], injections: Node[], toPass: Node[]): Runtime.Node[];
    split(context: ReferenceContext): FlowLevel[];
}
export declare class DSLBase {
    static CurrentID: number;
    ID: number;
}
export declare class LinearFlow extends DSLBase {
    context: ReferenceContext;
    collector: FlowLevel;
    levels: FlowLevel[];
    results: Value[];
    parent: LinearFlow | undefined;
    constructor(func: LinearFlowFunction, parent?: LinearFlow);
    lib: any;
    createLib(): void;
    collect(node: Node): void;
    findReference(node: Node): Record | undefined;
    getInputRegisters(): Register[];
    find: (...args: FlowRecordArg[]) => ProxyReference;
    lookup: (record: Value) => {
        attribute: ProxyReference;
        value: ProxyReference;
    };
    record: (...args: FlowRecordArg[]) => ProxyReference;
    not: (func: Function) => void;
    union: (...branches: Function[]) => ProxyReference[];
    choose: (...branches: Function[]) => ProxyReference[];
    gather: (...projection: Reference[]) => AggregateBuilder;
    unify(): void;
    compile(_?: Node[]): Runtime.Node[];
    transform(func: LinearFlowFunction): LinearFlowFunction;
    transformCode: (code: string, functionArgs: string[]) => string;
}
export declare class WatchFlow extends LinearFlow {
    collect(node: Node): void;
}
export declare class CommitFlow extends LinearFlow {
    collect(node: Node): void;
}
export declare class Record extends DSLBase {
    context: ReferenceContext;
    record?: Reference | undefined;
    attributes: Value[];
    constructor(context: ReferenceContext, tags?: string[], attributes?: RecordAttributes, record?: Reference | undefined);
    createReference(): Reference;
    createSub(context: ReferenceContext, record?: Reference): Record;
    reference(): Reference;
    add(context: ReferenceContext, attribute: Value, value: Value | Value[]): void;
    remove(context: ReferenceContext, attribute: Value, value: Value | Value[]): void;
    copyToContext(activeContext: ReferenceContext): Record;
    findAttribute(name: string): Reference | undefined;
    access(refContext: ReferenceContext, activeContext: ReferenceContext, prop: string): Reference;
    getRegisters(): Register[];
    compile(): (Runtime.Node | Runtime.Scan)[];
}
export declare class Lookup extends DSLBase {
    context: ReferenceContext;
    record: Value;
    attribute: Reference;
    value: Reference;
    constructor(context: ReferenceContext, record: Value);
    reference(): Reference;
    output(): {
        attribute: Reference;
        value: Reference;
    };
    compile(): Runtime.Scan[];
}
export declare class Move extends DSLBase {
    context: ReferenceContext;
    from: Value;
    to: Reference;
    constructor(context: ReferenceContext, from: Value, to?: Reference);
    toKey(): string;
    getInputRegisters(): Register[];
    getOutputRegisters(): Register[];
    compile(): Runtime.Constraint[];
}
export declare class Insert extends Record {
    context: ReferenceContext;
    constructor(context: ReferenceContext, tags?: string[], attributes?: RecordAttributes, record?: Reference);
    createReference(): Reference;
    createSub(context: ReferenceContext, record?: Reference): Record;
    add(context: ReferenceContext, attribute: Value, value: Value | Value[]): Reference;
    remove(context: ReferenceContext, attribute: Value, value: Value | Value[]): Reference;
    toWatch(): Watch;
    toCommit(): CommitInsert;
    compile(): any[];
}
export declare class Remove extends Insert {
    toCommit(): CommitRemove;
    compile(): any[];
}
export declare class Watch extends Insert {
    compile(): (Runtime.Node | Runtime.Scan)[];
}
export declare class CommitInsert extends Insert {
    compile(): any[];
}
export declare class CommitRemove extends Remove {
    compile(): any[];
}
export declare class Fn extends DSLBase {
    context: ReferenceContext;
    name: string;
    args: Value[];
    output: Value;
    constructor(context: ReferenceContext, name: string, args: Value[], output?: Reference);
    reference(): Value;
    access(refContext: ReferenceContext, activeContext: ReferenceContext, prop: string): void;
    getInputRegisters(): Register[];
    getOutputRegisters(): Register[];
    compile(): Runtime.Constraint[];
}
export declare class Aggregate extends DSLBase {
    context: ReferenceContext;
    aggregate: any;
    projection: Reference[];
    group: Reference[];
    args: Value[];
    output: Reference;
    constructor(context: ReferenceContext, aggregate: any, projection: Reference[], group: Reference[], args: Value[], output?: Reference);
    getJoinRegisters(): Register[];
    getInputRegisters(): Register[];
    getOutputRegisters(): Register[];
    compile(): any;
    reference(): Reference;
    per(...args: Reference[]): void;
}
export declare class AggregateBuilder {
    context: ReferenceContext;
    projection: Reference[];
    group: Reference[];
    constructor(context: ReferenceContext, projection: Reference[]);
    per(...args: Reference[]): this;
    checkBlock(): void;
    sum(value: Reference): any;
    count(): any;
    sort(...directions: Value[]): any;
}
export declare class Not extends LinearFlow {
    constructor(func: LinearFlowFunction, parent: LinearFlow);
}
export declare class Union extends DSLBase {
    context: ReferenceContext;
    branches: LinearFlow[];
    results: Reference[];
    inputs: Reference[];
    branchInputs: Reference[][];
    constructor(context: ReferenceContext, branchFunctions: Function[], parent: LinearFlow, existingResults?: Reference[]);
    setBranchInputs(branchIx: number, inputs: Reference[]): void;
    getInputRegisters(): Register[];
    getOutputRegisters(): Register[];
    resultCount(result: any): number;
    build(left: Runtime.Node, nodes: Runtime.Node[], inputs: Register[][], outputs: Register[], extraOuterJoins: Register[]): Runtime.Node;
    compile(join: Runtime.Node): Runtime.Node;
}
export declare class Choose extends Union {
    build(left: Runtime.Node, nodes: Runtime.Node[], inputs: Register[][], outputs: Register[], extraOuterJoins: Register[]): Runtime.Node;
}
export type EAVTuple = [RawValue, RawValue, RawValue];
export type EAVRCTuple = [RawValue, RawValue, RawValue, number, number];
export type TestChange = EAVTuple | EAVRCTuple;
export declare class Program {
    name: string;
    context: Runtime.EvaluationContext;
    blocks: Runtime.Block[];
    flows: LinearFlow[];
    index: indexes.Index;
    nodeCount: number;
    nextTransactionId: number;
    protected exporter: Exporter;
    protected lastWatch?: number;
    protected watchers: {
        [id: string]: Watcher | undefined;
    };
    protected _constants?: {
        [key: string]: RawValue;
    };
    constructor(name: string);
    constants(obj: {
        [key: string]: RawValue;
    }): this;
    injectConstants(func: LinearFlowFunction): LinearFlowFunction;
    clear(): void;
    _bind(name: string, flow: LinearFlow): Runtime.Block;
    bind(name: string, func: LinearFlowFunction): this;
    blockChangeTransaction(added: Runtime.Block[], removed: Runtime.Block[]): Runtime.BlockChangeTransaction;
    input(changes: Runtime.Change[]): Runtime.Transaction;
    inputEAVs(eavcs: (RawEAVC | RawEAV)[]): Runtime.Transaction;
    test(transaction: number, eavns: TestChange[]): this;
    _commit(name: string, flow: LinearFlow): Runtime.Block;
    commit(name: string, func: LinearFlowFunction): this;
    attach(id: string): Watcher;
    _watch(name: string, flow: WatchFlow): Runtime.Block;
    watch(name: string, func: LinearFlowFunction): this;
    asDiffs(handler: DiffConsumer): this;
    asObjects<Pattern extends RawRecord>(handler: ObjectConsumer<Pattern>): this;
    load(str: string): void;
}