import type { Operator } from "../Operator";
import type { StatefulEvt } from "./StatefulEvt";
import type { CtxLike } from "./CtxLike";
import type { Evt } from "./Evt";
import type { Handler } from "../Handler";
import type { AsyncIterableEvt } from "../AsyncIterableEvt";
export interface NonPostableEvt<T> {

    /** https://docs.evt.land/api/statefulevt#converting-an-evt-into-a-statefulevt */
    toStateful(initialState: T, ctx?: CtxLike): StatefulEvt<T>;
    toStateful(ctx?: CtxLike): StatefulEvt<T | undefined>;

    /** https://docs.evt.land/api/evt/evtattachdetach */
    readonly evtAttach: Evt<Handler<T, any>>;
    /** https://docs.evt.land/api/evt/evtattachdetach */
    readonly evtDetach: Evt<Handler<T, any>>;

    /** https://docs.evt.land/api/evt/setmaxhandlers */
    setMaxHandlers(n: number): this;

    /** 
     * https://docs.evt.land/api/evt/post
     * 
     * Number of times .post(data) have been called.
     */
    readonly postCount: number;

    /** https://docs.evt.land/api/evt/enabletrace */
    enableTrace(
        params: {
            id: string,
            formatter?: (data: T) => string,
            log?: ((message?: any, ...optionalParams: any[]) => void) | false
        }
        //NOTE: Not typeof console.log as we don't want to expose types from node
    ): void;

    /** https://docs.evt.land/api/evt/enabletrace */
    disableTrace(): this;

    /** 
     * TODO: Update doc, it replace: https://docs.evt.land/api/evt/getstatelessop 
     * Maybe this feature is too confusing to be documented...
     * */
    getInvocableOp<U>(op: Operator<T, U>): Operator.fλ.Stateless<T, U>;

    /** TODO: DOC !!! */
    isHandledByOp<U>(op: Operator<T, U>, data: T): boolean;

    /**
     * https://docs.evt.land/api/evt/ishandled
     * 
     * Test if posting a given event data will have an effect.
     * 
     * Return true if:
     * -There is at least one handler matching
     * this event data ( at least one handler's callback function
     * will be invoked if the data is posted. )
     * -Handlers could be will be detached
     * if the event data is posted.
     * 
     */
    isHandled(data: T): boolean;

    /** https://docs.evt.land/api/evt/gethandler */
    getHandlers(): Handler<T, any>[];

    /** 
     * https://docs.evt.land/api/evt/detach
     * 
     * Detach every handlers of the Evt that are bound to the provided context 
     * */
    detach<CtxResult>(ctx: CtxLike<CtxResult>): Handler<T, any, CtxLike<CtxResult>>[];
    /** 
     * https://docs.evt.land/api/evt/detach
     * 
     * (unsafe) Detach every handlers from the Evt 
     * */
    detach(): Handler<T, any>[];

    /** https://docs.evt.land/api/evt/pipe */
    pipe(): Evt<T>;

    pipe<U>(
        op: Operator.fλ<T, U>
    ): Evt<U>;
    pipe<U extends T>(
        op: (data: T) => data is U
    ): Evt<U>;
    pipe(
        op: (data: T) => boolean
    ): Evt<T>;

    pipe(ctx: CtxLike): Evt<T>;

    pipe<U>(
        ctx: CtxLike,
        op: Operator.fλ<T, U>
    ): Evt<U>;
    pipe<U extends T>(
        ctx: CtxLike,
        op: (data: T) => data is U
    ): Evt<U>;
    pipe(
        ctx: CtxLike,
        op: (data: T) => boolean
    ): Evt<T>;

    pipe<B, C>(
        op1: Operator.fλ<T, B>,
        op2: Operator.fλ<B, C>
    ): Evt<C>;
    pipe<B, C extends B>(
        op1: Operator.fλ<T, B>,
        op2: (data: B) => data is C
    ): Evt<C>;
    pipe<B>(
        op1: Operator.fλ<T, B>,
        op2: (data: B) => boolean
    ): Evt<B>;
    pipe<B extends T, C>(
        op1: (data: T) => data is B,
        op2: Operator.fλ<B, C>
    ): Evt<B>;
    pipe<B>(
        op1: (data: T) => boolean,
        op2: Operator.fλ<T, B>
    ): Evt<B>;
    pipe<B extends T, C extends B>(
        op1: (data: T) => data is B,
        op2: (data: B) => data is C
    ): Evt<C>;
    pipe<B extends T>(
        op1: (data: T) => data is B,
        op2: (data: B) => boolean
    ): Evt<B>;
    pipe<B extends T>(
        op1: (data: T) => boolean,
        op2: (data: T) => data is B
    ): Evt<B>;
    pipe<T>(
        op1: (data: T) => boolean,
        op2: (data: T) => boolean
    ): Evt<T>;


    pipe<B, C, D>(
        op1: Operator.fλ<T, B>,
        op2: Operator.fλ<B, C>,
        op3: Operator.fλ<C, D>
    ): Evt<D>;

    pipe<B, C, D, E>(
        op1: Operator.fλ<T, B>,
        op2: Operator.fλ<B, C>,
        op3: Operator.fλ<C, D>,
        op4: Operator.fλ<D, E>
    ): Evt<E>;

    pipe<B, C, D, E>(
        op1: Operator.fλ<T, B>,
        op2: Operator.fλ<B, C>,
        op3: Operator.fλ<C, D>,
        op4: Operator.fλ<D, E>
    ): Evt<E>;

    pipe<B, C, D, E, F>(
        op1: Operator.fλ<T, B>,
        op2: Operator.fλ<B, C>,
        op3: Operator.fλ<C, D>,
        op4: Operator.fλ<D, E>,
        op5: Operator.fλ<E, F>
    ): Evt<F>;


    pipe<B, C>(
        op1: Operator<T, B>,
        op2: Operator<B, C>
    ): Evt<C>;

    pipe<B, C, D>(
        op1: Operator<T, B>,
        op2: Operator<B, C>,
        op3: Operator<C, D>
    ): Evt<D>;

    pipe<B, C, D, E>(
        op1: Operator<T, B>,
        op2: Operator<B, C>,
        op3: Operator<C, D>,
        op4: Operator<D, E>
    ): Evt<E>;

    pipe<B, C, D, E, F>(
        op1: Operator<T, B>,
        op2: Operator<B, C>,
        op3: Operator<C, D>,
        op4: Operator<D, E>,
        op5: Operator<E, F>
    ): Evt<F>;

    pipe(
        ...ops: [
            Operator<T, any>,
            ...Operator<any, any>[]
        ]
    ): Evt<any>;

    pipe<T>(
        ...ops: [
            Operator<T, any>,
            ...Operator<any, any>[]
        ]
    ): Evt<any>;

    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout?
     */
    waitFor<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        timeout?: number
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout?
     */
    waitFor<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout?: number
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout?
     */
    waitFor(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout?: number
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - fλ
     * 
     * timeout?
     */
    waitFor<U>(
        op: Operator.fλ.Stateless<T, U>,
        timeout?: number
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - Type guard
     * 
     * timeout?
     */
    waitFor<Q extends T>(
        op: (data: T) => data is Q,
        timeout?: number
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * op - Filter
     * 
     * timeout?
     */
    waitFor(
        op: (data: T) => boolean,
        timeout?: number
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * ctx
     * 
     * timeout?
     */
    waitFor(
        ctx: CtxLike,
        timeout?: number
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/waitfor
     * 
     * timeout?
     */
    waitFor(
        timeout?: number
    ): Promise<T>;

    [Symbol.asyncIterator](): AsyncIterator<T>;

    /**
    * https://docs.evt.land/api/evt/iter
    * 
    * op - fλ
    * 
    * ctx
    * 
    * timeout?
    */
    iter<U, CtxResult>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike<CtxResult>,
        timeout?: number
    ): AsyncIterableEvt<U, CtxResult>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout?
     */
    iter<Q extends T, CtxResult>(
        op: (data: T) => data is Q,
        ctx: CtxLike<CtxResult>,
        timeout?: number
    ): AsyncIterableEvt<Q, CtxResult>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout?
     */
    iter<CtxResult>(
        op: (data: T) => boolean,
        ctx: CtxLike<CtxResult>,
        timeout?: number
    ): AsyncIterableEvt<T, CtxResult>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * op - fλ
     * 
     * timeout?
     */
    iter<U, CtxResult>(
        op: Operator.fλ.Stateless<T, U>,
        timeout?: number
    ): AsyncIterableEvt<U>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * op - Type guard
     * 
     * timeout?
     */
    iter<Q extends T>(
        op: (data: T) => data is Q,
        timeout?: number
    ): AsyncIterableEvt<Q>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * op - Filter
     * 
     * timeout?
     */
    iter(
        op: (data: T) => boolean,
        timeout?: number
    ): AsyncIterableEvt<T>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * ctx
     * 
     * timeout?
     */
    iter<CtxResult>(
        ctx: CtxLike,
        timeout?: number
    ): AsyncIterableEvt<T, CtxResult>;
    /**
     * https://docs.evt.land/api/evt/iter
     * 
     * timeout?
     */
    iter(
        timeout?: number
    ): AsyncIterableEvt<T, void>;


    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attach<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attach<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attach<U>(
        op: Operator.fλ<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attach<U>(
        op: Operator.fλ<T, U>,
        callback: (transformedData: U) => void
    ): this;







    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     * 
     */
    attach<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attach(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attach() method )
     */
    attach(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attach(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attach(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback 
     */
    attach(
        callback: (data: T) => void
    ): this;




    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attachOnce() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attachOnce() without the '$' prefix.
     */
    $attachOnce<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attachOnce() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attachOnce() without the '$' prefix.
     */
    $attachOnce<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attachOnce() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attachOnce() without the '$' prefix.
     */
    $attachOnce<U>(
        op: Operator.fλ.Stateless<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attachOnce() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attachOnce() without the '$' prefix.
     */
    $attachOnce<U>(
        op: Operator.fλ.Stateless<T, U>,
        callback: (transformedData: U) => void
    ): this;






    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOnce(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     * 
     * NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean )
     * the '$' prefix should be used ( use the $attachOnce() method )
     */
    attachOnce(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attachOnce(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attachOnce(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback
     */
    attachOnce(
        callback: (data: T) => void
    ): this;





    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachExtract<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachExtract<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachExtract<U>(
        op: Operator.fλ<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachExtract<U>(
        op: Operator.fλ<T, U>,
        callback: (transformedData: U) => void
    ): this;








    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachExtract<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachExtract(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     */
    attachExtract<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     */
    attachExtract(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     */
    attachExtract<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     */
    attachExtract(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     */
    attachExtract(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     */
    attachExtract<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     */
    attachExtract(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attachExtract(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attachExtract(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback
     */
    attachExtract(
        callback: (data: T) => void
    ): this;











    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachPrepend<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachPrepend<U>(
        op: Operator.fλ<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachPrepend<U>(
        op: Operator.fλ<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachPrepend<U>(
        op: Operator.fλ<T, U>,
        callback: (transformedData: U) => void
    ): this;









    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;

    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;

    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     */
    attachPrepend<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     */
    attachPrepend(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     */
    attachPrepend<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     */
    attachPrepend(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attachPrepend(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attachPrepend(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback
     */
    attachPrepend(
        callback: (data: T) => void
    ): this;







    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOncePrepend<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOncePrepend<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOncePrepend<U>(
        op: Operator.fλ.Stateless<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOncePrepend<U>(
        op: Operator.fλ.Stateless<T, U>,
        callback: (transformedData: U) => void
    ): this;









    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     */
    attachOncePrepend<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     */
    attachOncePrepend(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     */
    attachOncePrepend<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     */
    attachOncePrepend(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attachOncePrepend(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attachOncePrepend(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback
     */
    attachOncePrepend(
        callback: (data: T) => void
    ): this;








    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOnceExtract<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * ctx
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOnceExtract<U>(
        op: Operator.fλ.Stateless<T, U>,
        ctx: CtxLike,
        callback: (transformedData: U) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * timeout
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOnceExtract<U>(
        op: Operator.fλ.Stateless<T, U>,
        timeout: number,
        callback: (transformedData: U) => void
    ): Promise<U>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - fλ
     * 
     * callback
     * 
     * NOTE: $attach() with '$' is to use only with fλ operators,
     * if your operator return a boolean use the attach() without the '$' prefix.
     */
    $attachOnceExtract<U>(
        op: Operator.fλ.Stateless<T, U>,
        callback: (transformedData: U) => void
    ): this;








    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOnceExtract<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * timeout
     * 
     * callback
     */
    attachOnceExtract(
        op: (data: T) => boolean,
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * ctx
     * 
     * callback
     */
    attachOnceExtract<Q extends T>(
        op: (data: T) => data is Q,
        ctx: CtxLike,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * ctx
     * 
     * callback
     */
    attachOnceExtract(
        op: (data: T) => boolean,
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * timeout
     * 
     * callback
     */
    attachOnceExtract<Q extends T>(
        op: (data: T) => data is Q,
        timeout: number,
        callback: (data: Q) => void
    ): Promise<Q>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * timeout
     * 
     * callback
     */
    attachOnceExtract(
        op: (data: T) => boolean,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * timeout
     */
    attachOnceExtract(
        ctx: CtxLike,
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Type guard
     * 
     * callback
     */
    attachOnceExtract<Q extends T>(
        op: (data: T) => data is Q,
        callback: (data: Q) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * op - Filter
     * 
     * callback
     */
    attachOnceExtract(
        op: (data: T) => boolean,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * ctx
     * 
     * callback
     */
    attachOnceExtract(
        ctx: CtxLike,
        callback: (data: T) => void
    ): this;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * timeout
     * 
     * callback
     */
    attachOnceExtract(
        timeout: number,
        callback: (data: T) => void
    ): Promise<T>;
    /**
     * https://docs.evt.land/api/evt/attach
     * 
     * callback
     */
    attachOnceExtract(
        callback: (data: T) => void
    ): this;

}