import { Source, Subscriber, Subscription } from "../_core";
import { Transaction } from "../_tx";
export declare enum EventType {
    NEXT = 1,
    ERROR = 2,
    END = 3
}
export declare abstract class Operator<A, B> implements Subscriber<A>, Source<B>, Subscription {
    protected source: Source<A>;
    readonly weight: number;
    protected sink: Subscriber<B>;
    protected active: boolean;
    protected ord: number;
    protected subs: Subscription;
    constructor(source: Source<A>);
    subscribe(subscriber: Subscriber<B>, order: number): Subscription;
    activate(initialNeeded: boolean): void;
    reorder(order: number): void;
    dispose(): void;
    abstract next(tx: Transaction, val: A): void;
    error(tx: Transaction, err: Error): void;
    end(tx: Transaction): void;
    protected init(subscriber: Subscriber<B>, order: number, subscription: Subscription): void;
}
export interface PipeSubscriber<T> {
    pipedNext(sender: Pipe<T>, tx: Transaction, val: T): void;
    pipedError(sender: Pipe<T>, tx: Transaction, err: Error): void;
    pipedEnd(sender: Pipe<T>, tx: Transaction): void;
}
export declare class Pipe<T> implements Subscriber<T> {
    s: PipeSubscriber<T>;
    constructor(s: PipeSubscriber<T>);
    next(tx: Transaction, val: T): void;
    error(tx: Transaction, err: Error): void;
    end(tx: Transaction): void;
}
export declare class LinkedPipe<T> extends Pipe<T> {
    h: LinkedPipe<T> | null;
    t: LinkedPipe<T> | null;
    constructor(s: PipeSubscriber<T>, h: LinkedPipe<T> | null, t: LinkedPipe<T> | null);
}
export declare class LinkedPipeList<T> {
    size: number;
    private h;
    constructor(subscribers: Array<PipeSubscriber<T>>);
    head(): LinkedPipe<T> | null;
    append(subscriber: PipeSubscriber<T>): LinkedPipe<T>;
    remove(node: LinkedPipe<T>): void;
    clear(): void;
}
export declare class Identity<T> extends Operator<T, T> {
    next(tx: Transaction, val: T): void;
}