import "../_dnt.polyfills.js";
import { Mutex } from "./Mutex.js";
import { PromiseOut } from "./PromiseOut.js";
import { Signal, type $Callback } from "./createSignal.js";
import { CUSTOM_INSPECT } from "./logger.js";
type Event<T> = ReturnType<Producer<T>["event"]>;
/**生产者 */
export declare class Producer<T> {
    #private;
    readonly name: string;
    readonly console: import("./logger.js").Logger;
    constructor(name: string, options?: {
        bufferLimit?: number;
        bufferOverflowBehavior?: "warn" | "throw" | "slient";
    });
    readonly bufferLimit: number;
    readonly bufferOverflowBehavior: "warn" | "throw" | "slient";
    toString(): string;
    [CUSTOM_INSPECT](): string;
    private event;
    protected consumers: Set<{
        readonly name: string;
        readonly producer: Producer<T>;
        toString(): string;
        /**输入 */
        readonly input: {
            "__#6@#cb"?: ((event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown) | undefined;
            close(): void;
            /**收集消息 */
            collect(cb: (event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown): void;
            emit(event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }): Promise<void>;
        };
        /**标记是否开始消费 */
        "__#7@#started": boolean;
        readonly started: boolean;
        startingBuffers: Set<{
            readonly data: T;
            readonly producer: Producer<T>;
            toString(): string;
            "__#5@#job": PromiseOut<void>;
            readonly job: Promise<void>;
            /**标记事件是否被消耗 */
            "__#5@#consumeTimes": number;
            readonly consumed: boolean;
            /**
             * 事件消耗器，调用后事件被标记成已消耗，这意味着：
             * 1. 现有的消费者还是能看到它
             * 2. 其它后来的消费者不会再看到它
             */
            consume(): T;
            /**
             * 事件停止传播，调用后事件不会被其他消费者触发
             */
            "__#5@#stoped": boolean;
            readonly stoped: boolean;
            /**
             * 停止传播
             *
             * 事件消费，并停止向其它消费器继续传播
             */
            stopImmediatePropagation(): void;
            /**
             * 在 complete 的时候再进行 remove
             */
            complete(): void;
            /**过滤触发 */
            consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
            consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
            "__#5@#emitLock": Mutex;
            emitBy(consumer: any): Promise<void> | undefined;
            "inspect.custom"(): string;
        }> | null;
        "__#7@#errorCatcher": PromiseOut<string | undefined>;
        /**开始触发之前的 */
        "__#7@#start"(): void;
        /**收集事件 */
        collect(collector: (event: {
            readonly data: T;
            readonly producer: Producer<T>;
            toString(): string;
            "__#5@#job": PromiseOut<void>;
            readonly job: Promise<void>;
            /**标记事件是否被消耗 */
            "__#5@#consumeTimes": number;
            readonly consumed: boolean;
            /**
             * 事件消耗器，调用后事件被标记成已消耗，这意味着：
             * 1. 现有的消费者还是能看到它
             * 2. 其它后来的消费者不会再看到它
             */
            consume(): T;
            /**
             * 事件停止传播，调用后事件不会被其他消费者触发
             */
            "__#5@#stoped": boolean;
            readonly stoped: boolean;
            /**
             * 停止传播
             *
             * 事件消费，并停止向其它消费器继续传播
             */
            stopImmediatePropagation(): void;
            /**
             * 在 complete 的时候再进行 remove
             */
            complete(): void;
            /**过滤触发 */
            consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
            consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
            "__#5@#emitLock": Mutex;
            emitBy(consumer: any): Promise<void> | undefined;
            "inspect.custom"(): string;
        }) => void): void;
        mapNotNull<R_2>(transform: (value: T) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
        "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
        onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
        close(cause?: string): void;
        "inspect.custom"(): string;
    }>;
    protected buffers: Set<{
        readonly data: T;
        readonly producer: Producer<T>;
        toString(): string;
        "__#5@#job": PromiseOut<void>;
        readonly job: Promise<void>;
        /**标记事件是否被消耗 */
        "__#5@#consumeTimes": number;
        readonly consumed: boolean;
        /**
         * 事件消耗器，调用后事件被标记成已消耗，这意味着：
         * 1. 现有的消费者还是能看到它
         * 2. 其它后来的消费者不会再看到它
         */
        consume(): T;
        /**
         * 事件停止传播，调用后事件不会被其他消费者触发
         */
        "__#5@#stoped": boolean;
        readonly stoped: boolean;
        /**
         * 停止传播
         *
         * 事件消费，并停止向其它消费器继续传播
         */
        stopImmediatePropagation(): void;
        /**
         * 在 complete 的时候再进行 remove
         */
        complete(): void;
        /**过滤触发 */
        consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
        consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
        "__#5@#emitLock": Mutex;
        emitBy(consumer: {
            readonly name: string;
            readonly producer: Producer<T>;
            toString(): string;
            /**输入 */
            readonly input: {
                "__#6@#cb"?: ((event: any) => unknown) | undefined;
                close(): void;
                /**收集消息 */
                collect(cb: (event: any) => unknown): void;
                emit(event: any): Promise<void>;
            };
            /**标记是否开始消费 */
            "__#7@#started": boolean;
            readonly started: boolean;
            startingBuffers: Set<any> | null;
            "__#7@#errorCatcher": PromiseOut<string | undefined>;
            /**开始触发之前的 */
            "__#7@#start"(): void;
            /**收集事件 */
            collect(collector: (event: any) => void): void;
            mapNotNull<R_2>(transform: (value: T) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
            "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
            onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
            close(cause?: string): void;
            "inspect.custom"(): string;
        }): Promise<void> | undefined;
        "inspect.custom"(): string;
    }>;
    /** 保证发送 */
    send(value: T): void;
    /**无保证发送 */
    sendBeacon(value: T): Promise<void>;
    trySend(value: T): Promise<void>;
    /**触发该消息 */
    protected doEmit(event: Event<T>): Promise<void>;
    /**
     * 创建一个消费者
     */
    consumer(name: string): {
        readonly name: string;
        readonly producer: Producer<T>;
        toString(): string;
        /**输入 */
        readonly input: {
            "__#6@#cb"?: ((event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown) | undefined;
            close(): void;
            /**收集消息 */
            collect(cb: (event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown): void;
            emit(event: {
                readonly data: T;
                readonly producer: Producer<T>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: any): Promise<void> | undefined;
                "inspect.custom"(): string;
            }): Promise<void>;
        };
        /**标记是否开始消费 */
        "__#7@#started": boolean;
        readonly started: boolean;
        startingBuffers: Set<{
            readonly data: T;
            readonly producer: Producer<T>;
            toString(): string;
            "__#5@#job": PromiseOut<void>;
            readonly job: Promise<void>;
            /**标记事件是否被消耗 */
            "__#5@#consumeTimes": number;
            readonly consumed: boolean;
            /**
             * 事件消耗器，调用后事件被标记成已消耗，这意味着：
             * 1. 现有的消费者还是能看到它
             * 2. 其它后来的消费者不会再看到它
             */
            consume(): T;
            /**
             * 事件停止传播，调用后事件不会被其他消费者触发
             */
            "__#5@#stoped": boolean;
            readonly stoped: boolean;
            /**
             * 停止传播
             *
             * 事件消费，并停止向其它消费器继续传播
             */
            stopImmediatePropagation(): void;
            /**
             * 在 complete 的时候再进行 remove
             */
            complete(): void;
            /**过滤触发 */
            consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
            consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
            "__#5@#emitLock": Mutex;
            emitBy(consumer: any): Promise<void> | undefined;
            "inspect.custom"(): string;
        }> | null;
        "__#7@#errorCatcher": PromiseOut<string | undefined>;
        /**开始触发之前的 */
        "__#7@#start"(): void;
        /**收集事件 */
        collect(collector: (event: {
            readonly data: T;
            readonly producer: Producer<T>;
            toString(): string;
            "__#5@#job": PromiseOut<void>;
            readonly job: Promise<void>;
            /**标记事件是否被消耗 */
            "__#5@#consumeTimes": number;
            readonly consumed: boolean;
            /**
             * 事件消耗器，调用后事件被标记成已消耗，这意味着：
             * 1. 现有的消费者还是能看到它
             * 2. 其它后来的消费者不会再看到它
             */
            consume(): T;
            /**
             * 事件停止传播，调用后事件不会被其他消费者触发
             */
            "__#5@#stoped": boolean;
            readonly stoped: boolean;
            /**
             * 停止传播
             *
             * 事件消费，并停止向其它消费器继续传播
             */
            stopImmediatePropagation(): void;
            /**
             * 在 complete 的时候再进行 remove
             */
            complete(): void;
            /**过滤触发 */
            consumeMapNotNull<R>(mapNotNull: (data: T) => R | undefined): R | undefined;
            consumeFilter<R_1 extends T = T>(filter: (data: T) => boolean | undefined): R_1 | undefined;
            "__#5@#emitLock": Mutex;
            emitBy(consumer: any): Promise<void> | undefined;
            "inspect.custom"(): string;
        }) => void): void;
        mapNotNull<R_2>(transform: (value: T) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
        "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
        onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
        close(cause?: string | undefined): void;
        "inspect.custom"(): string;
    };
    static EasyFlow: {
        new <T_1>(): {
            "__#6@#cb"?: ((event: {
                readonly data: T_1;
                readonly producer: Producer<T_1>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T_1;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T_1) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T_1 = T_1>(filter: (data: T_1) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: {
                    readonly name: string;
                    readonly producer: Producer<T_1>;
                    toString(): string;
                    /**输入 */
                    readonly input: {
                        "__#6@#cb"?: any | undefined;
                        close(): void;
                        /**收集消息 */
                        collect(cb: (event: any) => unknown): void;
                        emit(event: any): Promise<void>;
                    };
                    /**标记是否开始消费 */
                    "__#7@#started": boolean;
                    readonly started: boolean;
                    startingBuffers: Set<any> | null;
                    "__#7@#errorCatcher": PromiseOut<string | undefined>;
                    /**开始触发之前的 */
                    "__#7@#start"(): void;
                    /**收集事件 */
                    collect(collector: (event: any) => void): void;
                    mapNotNull<R_2>(transform: (value: T_1) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
                    "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
                    onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
                    close(cause?: string): void;
                    "inspect.custom"(): string;
                }): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown) | undefined;
            close(): void;
            /**收集消息 */
            collect(cb: (event: {
                readonly data: T_1;
                readonly producer: Producer<T_1>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T_1;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T_1) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T_1 = T_1>(filter: (data: T_1) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: {
                    readonly name: string;
                    readonly producer: Producer<T_1>;
                    toString(): string;
                    /**输入 */
                    readonly input: {
                        "__#6@#cb"?: ((event: any) => unknown) | undefined;
                        close(): void;
                        /**收集消息 */
                        collect(cb: any): void;
                        emit(event: any): Promise<void>;
                    };
                    /**标记是否开始消费 */
                    "__#7@#started": boolean;
                    readonly started: boolean;
                    startingBuffers: Set<any> | null;
                    "__#7@#errorCatcher": PromiseOut<string | undefined>;
                    /**开始触发之前的 */
                    "__#7@#start"(): void;
                    /**收集事件 */
                    collect(collector: (event: any) => void): void;
                    mapNotNull<R_2>(transform: (value: T_1) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
                    "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
                    onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
                    close(cause?: string): void;
                    "inspect.custom"(): string;
                }): Promise<void> | undefined;
                "inspect.custom"(): string;
            }) => unknown): void;
            emit(event: {
                readonly data: T_1;
                readonly producer: Producer<T_1>;
                toString(): string;
                "__#5@#job": PromiseOut<void>;
                readonly job: Promise<void>;
                /**标记事件是否被消耗 */
                "__#5@#consumeTimes": number;
                readonly consumed: boolean;
                /**
                 * 事件消耗器，调用后事件被标记成已消耗，这意味着：
                 * 1. 现有的消费者还是能看到它
                 * 2. 其它后来的消费者不会再看到它
                 */
                consume(): T_1;
                /**
                 * 事件停止传播，调用后事件不会被其他消费者触发
                 */
                "__#5@#stoped": boolean;
                readonly stoped: boolean;
                /**
                 * 停止传播
                 *
                 * 事件消费，并停止向其它消费器继续传播
                 */
                stopImmediatePropagation(): void;
                /**
                 * 在 complete 的时候再进行 remove
                 */
                complete(): void;
                /**过滤触发 */
                consumeMapNotNull<R>(mapNotNull: (data: T_1) => R | undefined): R | undefined;
                consumeFilter<R_1 extends T_1 = T_1>(filter: (data: T_1) => boolean | undefined): R_1 | undefined;
                "__#5@#emitLock": Mutex;
                emitBy(consumer: {
                    readonly name: string;
                    readonly producer: Producer<T_1>;
                    toString(): string;
                    /**输入 */
                    readonly input: {
                        "__#6@#cb"?: ((event: any) => unknown) | undefined;
                        close(): void;
                        /**收集消息 */
                        collect(cb: (event: any) => unknown): void;
                        emit(event: any): Promise<void>;
                    };
                    /**标记是否开始消费 */
                    "__#7@#started": boolean;
                    readonly started: boolean;
                    startingBuffers: Set<any> | null;
                    "__#7@#errorCatcher": PromiseOut<string | undefined>;
                    /**开始触发之前的 */
                    "__#7@#start"(): void;
                    /**收集事件 */
                    collect(collector: (event: any) => void): void;
                    mapNotNull<R_2>(transform: (value: T_1) => R_2 | undefined): (cb: $Callback<[R_2]>) => import("./createSignal.js").$OffListener;
                    "__#7@#destroySignal": Signal<$Callback<[], unknown>>;
                    onDestroy: (cb: $Callback<[], unknown>) => import("./createSignal.js").$OffListener;
                    close(cause?: string): void;
                    "inspect.custom"(): string;
                }): Promise<void> | undefined;
                "inspect.custom"(): string;
            }): Promise<void>;
        };
    };
    get isClosedForSend(): boolean;
    /**全部关闭 */
    close(cause?: string): Promise<void>;
    onClosed: (cb: () => unknown) => import("./createSignal.js").$OffListener;
}
export {};
//# sourceMappingURL=Producer.d.ts.map