import { Duration, Listener } from "./@types";
import { Subscription } from "./subscription.class";
import { Descriptor } from "./subscription.class";
import { AsTuple } from "./types/astuple.type";
export declare class Signal<T> {
    private _subscriptions;
    private Clean;
    Derive(old: Signal<T>): Signal<T>;
    Copy(): Signal<T>;
    Clear(): void;
    Listen(listener: Listener<T>, duration?: Duration): Subscription<T>;
    Emit(data: T): void;
    Then<U>(signal: Signal<U>): Connector<U, T>;
    Until<U>(signal: Signal<U>): Interruptor<U, T>;
    When(condition: (event: T) => boolean): When<T>;
    Map<U>(map: (event: T) => U): Mapper<U, T>;
    Along<U>(signal: Signal<U>, map: (event: T) => U): Synchronizator<U, T>;
}
export declare class Tracker<A, B> extends Signal<[...AsTuple<B>, ...AsTuple<A>]> {
    private _signal;
    private _parent;
    private _actives;
    private _setups;
    constructor(_signal: Signal<A>, _parent: Signal<B>);
    protected TrackSetup(setup: Descriptor): Descriptor;
    protected TrackActive(active: Descriptor): Descriptor;
    protected ClearActives(): void;
    Clear(): void;
    Dispose(): void;
    get Signal(): Signal<A>;
    get Parent(): Signal<B>;
}
export declare class Synchronizator<A, B> extends Signal<B> {
    private _subscription;
    constructor(signal: Signal<A>, parent: Signal<B>, map: (event: B) => A);
    Dispose(): void;
}
export declare class Connector<A, B> extends Tracker<A, B> {
    constructor(signal: Signal<A>, parent: Signal<B>);
}
export declare class Interruptor<A, B> extends Tracker<A, B> {
    constructor(signal: Signal<A>, parent: Signal<B>);
}
export declare class When<T> extends Signal<T> {
    private _subscription;
    constructor(signal: Signal<T>, condition: (event: T) => boolean);
    Dispose(): void;
}
export declare class Mapper<U, T> extends Signal<U> {
    private _subscription;
    constructor(signal: Signal<T>, map: (event: T) => U);
    Dispose(): void;
}