@electric-sql/d2ts/dist/graph.d.ts

D2TS is a TypeScript implementation of Differential Dataflow.

import { MultiSet, MultiSetArray } from './multiset.js';
import { Version, Antichain } from './order.js';
import { Message, IOperator, IDifferenceStreamReader, IDifferenceStreamWriter } from './types.js';
/**
 * A read handle to a dataflow edge that receives data and frontier updates from a writer.
 *
 * The data received over this edge are pairs of (version, MultiSet) and the frontier
 * updates are either integers (in the one dimensional case) or Antichains (in the general
 * case).
 */
export declare class DifferenceStreamReader<T> implements IDifferenceStreamReader<T> {
    #private;
    constructor(queue: Message<T>[]);
    drain(): Message<T>[];
    isEmpty(): boolean;
    probeFrontierLessThan(frontier: Antichain): boolean;
}
/**
 * A write handle to a dataflow edge that is allowed to publish data and send
 * frontier updates.
 */
export declare class DifferenceStreamWriter<T> implements IDifferenceStreamWriter<T> {
    #private;
    frontier: Antichain | null;
    sendData(version: Version | number | number[], collection: MultiSet<T> | MultiSetArray<T>): void;
    sendFrontier(frontier: Antichain | Version | number | number[]): void;
    newReader(): DifferenceStreamReader<T>;
}
/**
 * A generic implementation of a dataflow operator (node) that has multiple incoming edges (read handles) and
 * one outgoing edge (write handle).
 */
export declare abstract class Operator<T> implements IOperator<T> {
    id: number;
    protected inputs: DifferenceStreamReader<T>[];
    protected output: DifferenceStreamWriter<T>;
    protected inputFrontiers: Antichain[];
    protected outputFrontier: Antichain;
    constructor(id: number, inputs: DifferenceStreamReader<T>[], output: DifferenceStreamWriter<T>, initialFrontier: Antichain);
    abstract run(): void;
    hasPendingWork(): boolean;
    frontiers(): [Antichain[], Antichain];
}
/**
 * A convenience implementation of a dataflow operator that has a handle to one
 * incoming stream of data, and one handle to an outgoing stream of data.
 */
export declare abstract class UnaryOperator<T> extends Operator<T> {
    id: number;
    constructor(id: number, inputA: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>, initialFrontier: Antichain);
    inputMessages(): Message<T>[];
    inputFrontier(): Antichain;
    setInputFrontier(frontier: Antichain): void;
}
/**
 * A convenience implementation of a dataflow operator that has a handle to two
 * incoming streams of data, and one handle to an outgoing stream of data.
 */
export declare abstract class BinaryOperator<T> extends Operator<T> {
    id: number;
    constructor(id: number, inputA: DifferenceStreamReader<T>, inputB: DifferenceStreamReader<T>, output: DifferenceStreamWriter<T>, initialFrontier: Antichain);
    inputAMessages(): Message<T>[];
    inputAFrontier(): Antichain;
    setInputAFrontier(frontier: Antichain): void;
    inputBMessages(): Message<T>[];
    inputBFrontier(): Antichain;
    setInputBFrontier(frontier: Antichain): void;
}