import { type Result } from 'neverthrow';
import { createLinkedListQueue } from '../queue/linked-list-queue.js';
import type { Queue } from '../queue/queue.js';
import { createRingBufferQueue } from '../queue/ring-buffer-queue.js';
export { createLinkedListQueue, createRingBufferQueue, type Queue };
export type CreateBufferFn<T> = (size: number) => Result<Queue<T>, Error>;
export type MapOptions<T, E> = {
    concurrency?: number | AsyncChannel<number, E>;
    delay?: number | AsyncChannel<number, E>;
} & QueueOptions<T>;
export type QueueOptions<T> = {
    buffer?: Queue<T>;
    size?: number;
};
export type ChunkOptions<T> = {
    timeout?: number;
} & QueueOptions<T[]>;
export type AsyncChannel<T, E = Error> = {
    send: (value: T) => Promise<Result<undefined, Error>>;
    then: (onFulfilled: (value: Result<T, E>) => void) => void;
    close: (e?: Error) => E | undefined;
    clearAndClose: (e?: Error) => void;
    isClosed: boolean;
    error: Error | undefined;
    [Symbol.asyncIterator](): AsyncIterator<T>;
    toArray: () => T[];
    size: number;
    bufferedCount: number;
    pendingSends: number;
    pendingReceives: number;
    toString: () => string;
    map: <U>(fn: (value: T, options: {
        signal?: AbortSignal;
    }) => U, options?: MapOptions<Awaited<U>, E>) => AsyncChannel<Awaited<U>, E>;
    chunk: (size: number, options?: ChunkOptions<T>) => AsyncChannel<T[], E>;
    filter: (fn: (value: T, options: {
        signal?: AbortSignal;
    }) => boolean | Promise<boolean>, options?: QueueOptions<T>) => AsyncChannel<T, E>;
    forEach: (fn: (value: T, options: {
        signal?: AbortSignal;
    }) => Promise<void> | void, options?: {
        concurrency?: number | AsyncChannel<number, E>;
        delay?: number | AsyncChannel<number, E>;
        signal?: AbortSignal;
    }) => Promise<Result<undefined, Error>>;
};
export declare class AsyncChannelClosedError extends Error {
    constructor(cause: Error | undefined);
}
type SizeOrUnbounded = {
    unbounded: true;
    size?: undefined;
} | {
    unbounded?: false;
    size?: number;
};
type CreateAsyncChannelInput<T> = {
    signal?: AbortSignal;
    values?: Iterable<T>;
    generator?: (input?: {
        signal?: AbortSignal;
    }) => AsyncGenerator<T, any, any>;
} & SizeOrUnbounded;
type _CreateAsyncChannelInput<T> = CreateAsyncChannelInput<T> & {
    buffer: Queue<T>;
};
export declare function createChannelWithQueue<T>(input: _CreateAsyncChannelInput<T>): AsyncChannel<T, Error>;
export declare function createUnboundedChannel<T>(options?: Omit<CreateAsyncChannelInput<T>, 'size'>): AsyncChannel<T, Error>;
export declare function createChannel<T>(options?: Omit<CreateAsyncChannelInput<T>, 'unbounded'>): AsyncChannel<T, Error>;