modern-ts 0.8.0

package/dist/types/Other/lazy.d.ts

@@ -0,0 +1,127 @@
+import { AsyncResult, Result } from '../Result/types';
+import { UnknownError } from '../unknown-error';
+/**
+ * @typeParam T - The success value type.
+ */
+export type Lazy<T> = () => T;
+/**
+ * @typeParam T - The success value type.
+ */
+export type LazyAsync<T> = (signal?: AbortSignal) => Promise<T>;
+/**
+ * Wraps a concrete value into a synchronous Lazy function.
+ * @typeParam T - The type of the value.
+ * @param {T} value - The value to be lazily returned.
+ * @returns {Lazy<T>} A Lazy function that always returns the value.
+ */
+export declare const wrap: <T>(value: T) => Lazy<T>;
+/**
+ * Executes a synchronous Lazy function immediately.
+ * @typeParam T - The return type of the function.
+ * @param {Lazy<T>} fn - The Lazy function to execute.
+ * @returns {T} The computed result of the Lazy function.
+ */
+export declare const run: <T>(fn: Lazy<T>) => T;
+/**
+ * Wraps a concrete value into an asynchronous LazyAsync function.
+ * @typeParam T - The type of the value.
+ * @param {T} value - The value to be lazily returned.
+ * @returns {LazyAsync<T>} A LazyAsync function that asynchronously returns the value.
+ */
+export declare const wrapAsync: <T>(value: T) => LazyAsync<T>;
+/**
+ * Executes an asynchronous LazyAsync function immediately with optional abort signal.
+ * @typeParam T - The return type of the promise.
+ * @param {LazyAsync<T>} fn - The LazyAsync function to execute.
+ * @param {AbortSignal} [signal] - Optional AbortSignal to abort the operation.
+ * @returns {Promise<T>} The asynchronous computed result.
+ */
+export declare const runAsync: <T>(fn: LazyAsync<T>, signal?: AbortSignal) => Promise<T>;
+/**
+ * Executes a Lazy function only once and caches the result (Memoization).
+ * @typeParam T - The type of the computed value.
+ * @param {Lazy<T>} fn - The Lazy function to memoize.
+ * @returns {Lazy<T>} The memoized Lazy function.
+ */
+export declare function Memoized<T>(fn: Lazy<T>): Lazy<T>;
+/**
+ * Executes a LazyAsync function only once and caches the resulting Promise.
+ * Accepts AbortSignal which is passed to the underlying function on first call.
+ * Clears cache on abort to allow retries.
+ * @typeParam T - The type of the computed value.
+ * @param {LazyAsync<T>} fn - The LazyAsync function to memoize.
+ * @returns {LazyAsync<T>} The memoized LazyAsync function.
+ */
+export declare function AsyncMemoized<T>(fn: LazyAsync<T>): LazyAsync<T>;
+/**
+ * Executes a Lazy function within a try-catch block and ensures cleanup runs.
+ * Captures synchronous exceptions and wraps the result in Result.
+ * @typeParam T - The type of the success value.
+ * @param {Lazy<T>} fn - The Lazy function to execute.
+ * @param {() => void} [cleaner] - Optional synchronous cleanup function.
+ * @returns {Result<T, UnknownError>} Ok(T) on success, or Err(UnknownError) on exception.
+ */
+export declare function runWithCleanup<T>(fn: Lazy<T>, cleaner?: () => void): Result<T, UnknownError>;
+/**
+ * Executes LazyAsync with cleanup and abort support.
+ * @typeParam T - The type of the success value.
+ * @param {LazyAsync<T>} fn - The LazyAsync function to execute.
+ * @param {() => void | Promise<void>} [cleaner] - Optional cleanup function.
+ * @param {AbortSignal} [signal] - Optional AbortSignal to abort the operation. ✨ 新增参数
+ * @returns {AsyncResult<T, UnknownError>}
+ */
+export declare function runAsyncWithCleanup<T>(fn: LazyAsync<T>, cleaner?: () => void | Promise<void>, signal?: AbortSignal): AsyncResult<T, UnknownError>;
+/**
+ * Maps the result of a Lazy function to a new Lazy function (Functor map).
+ * @typeParam T - The input value type.
+ * @typeParam U - The output value type.
+ * @param {Lazy<T>} fn - The input Lazy function.
+ * @param {(value: T) => U} mapper - The synchronous mapping function.
+ * @returns {Lazy<U>} The composed Lazy function.
+ */
+export declare const map: <T, U>(fn: Lazy<T>, mapper: (value: T) => U) => Lazy<U>;
+/**
+ * Maps async LazyAsync result with abort support.
+ * @typeParam T - The input value type.
+ * @typeParam U - The output value type.
+ * @param {LazyAsync<T>} fn - The input LazyAsync function.
+ * @param {(value: T) => U | Promise<U>} mapper - Mapping function.
+ * @returns {LazyAsync<U>} Composed LazyAsync function.
+ */
+export declare const mapAsync: <T, U>(fn: LazyAsync<T>, mapper: (value: T) => U | Promise<U>) => LazyAsync<U>;
+/**
+ * Monadic bind operation (flatMap) for Lazy. Composes two Lazy functions.
+ * @typeParam T - The input value type.
+ * @typeParam U - The output value type.
+ * @param {Lazy<T>} fn - The initial Lazy function.
+ * @param {(value: T) => Lazy<U>} mapper - Maps the result T to a new Lazy<U>.
+ * @returns {Lazy<U>} The flattened composed Lazy function.
+ */
+export declare const andThen: <T, U>(fn: Lazy<T>, mapper: (value: T) => Lazy<U>) => Lazy<U>;
+/**
+ * Async monadic bind (flatMap) with abort support.
+ * @typeParam T - The input value type.
+ * @typeParam U - The output value type.
+ * @param {LazyAsync<T>} fn - Initial LazyAsync function.
+ * @param {(value: T) => LazyAsync<U>} mapper - Maps to new LazyAsync.
+ * @returns {LazyAsync<U>} Flattened composed function.
+ */
+export declare const andThenAsync: <T, U>(fn: LazyAsync<T>, mapper: (value: T) => LazyAsync<U>) => LazyAsync<U>;
+/**
+ * Combines the results of two Lazy functions into a tuple.
+ * @typeParam T - The type of the first value.
+ * @typeParam U - The type of the second value.
+ * @param {Lazy<T>} fn1 - The first Lazy function.
+ * @param {Lazy<U>} fn2 - The second Lazy function.
+ * @returns {Lazy<[T, U]>} A Lazy function returning the tuple [T, U].
+ */
+export declare const zip: <T, U>(fn1: Lazy<T>, fn2: Lazy<U>) => Lazy<[T, U]>;
+/**
+ * Concurrent execution of two LazyAsync with shared abort signal.
+ * @typeParam T - First value type.
+ * @typeParam U - Second value type.
+ * @param {LazyAsync<T>} fn1 - First LazyAsync function.
+ * @param {LazyAsync<U>} fn2 - Second LazyAsync function.
+ * @returns {LazyAsync<[T, U]>} Tuple result function.
+ */
+export declare const zipAsync: <T, U>(fn1: LazyAsync<T>, fn2: LazyAsync<U>) => LazyAsync<[T, U]>;

package/dist/types/Other/queue.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A FIFO (First-In-First-Out) queue implementation
+ * Uses circular buffer optimization to avoid O(n) shift operations
+ * @template T The type of elements stored in the queue
+ * @note It is recommended not to store `null` values in this queue, as `null` is used
+ * by `peek()` and `dequeue()` to indicate an empty queue.
+ * Storing `null` makes it impossible to distinguish between "queue is empty" and "actual null value stored".
+ */
+export declare class Queue<T> {
+    private queue_data;
+    private head_idx;
+    /**
+     * Returns the number of elements in the queue
+     */
+    get size(): number;
+    /**
+     * Checks if the queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the front element without removing it
+     * @returns The front element, or null if queue is empty
+     */
+    peek(): T | null;
+    /**
+     * Adds an element to the back of the queue
+     */
+    enqueue(item: T): void;
+    /**
+     * Removes and returns the front element from the queue
+     * @returns The front element, or null if queue is empty
+     */
+    dequeue(): T | null;
+    /**
+     * Removes all elements from the queue
+     */
+    clear(): void;
+    /**
+     * Converts the queue to an array (front element at index 0)
+     */
+    toArray(): T[];
+}

package/dist/types/Other/secret.d.ts

@@ -0,0 +1,111 @@
+/**
+ * A unique Symbol used to represent the state of a Secret instance when its original
+ * sensitive value has been destroyed or erased from memory.
+ * @internal
+ */
+export declare const EMPTY: unique symbol;
+export declare class SecretError extends Error {
+    constructor(message: string);
+}
+/**
+ * A secure container class for sensitive values (T).
+ *
+ * The class uses private fields, controlled access, and disposal mechanisms
+ * to protect data from accidental exposure in logs, serialization, and memory dumps.
+ *
+ * @template T The type of the sensitive value being protected.
+ * @implements {Disposable} (Implicitly, for TypeScript 5.2+ `using` support)
+ */
+export declare class Secret<T> {
+    #private;
+    /**
+     * Creates a new Secret container for the given sensitive value.
+     *
+     * @param {T} value The sensitive value (e.g., an API key or password) to be secured.
+     */
+    constructor(value: T);
+    /**
+     * A factory method to create a new Secret instance.
+     *
+     * @template T The type of the sensitive value.
+     * @param {T} value The sensitive value to be wrapped.
+     * @returns {Secret<T>} A new Secret instance containing the value.
+     */
+    static make<T>(value: T): Secret<T>;
+    /**
+     * Reveals the original sensitive value stored within the Secret container.
+     * This is the only intended method to retrieve the protected data.
+     *
+     * @template T The type of the value being revealed.
+     * @param {Secret<T>} secret The Secret instance to reveal the value from.
+     * @returns {T} The original sensitive value.
+     * @throws {Error} If the Secret value has already been destroyed (`destroy` or `using` block exited).
+     */
+    static reveal<T>(secret: Secret<T>): T;
+    /**
+     * Destroys the sensitive value by overwriting its memory location with the `Empty` Symbol.
+     * This minimizes the duration the sensitive data resides in memory.
+     *
+     * After destruction, `reveal()` will throw an error.
+     *
+     * @template T The type of the value being destroyed.
+     * @param {Secret<T>} secret The Secret instance to destroy.
+     */
+    static destroy<T>(secret: Secret<T>): void;
+    /**
+     * Executes a callback function with the revealed sensitive value and ensures the secret
+     * is destroyed immediately after the callback completes, regardless of success or failure.
+     *
+     * @template T The type of the sensitive value.
+     * @template R The return type of the callback function.
+     * @param {Secret<T>} secret The Secret instance to operate on.
+     * @param {(value: T) => R} callback The function to execute with the revealed value.
+     * @returns {R} The result of the callback function.
+     */
+    static dispose<T, R>(secret: Secret<T>, callback: (value: T) => R): R;
+    /**
+     * Executes an asynchronous callback function with the revealed sensitive value and ensures the secret
+     * is destroyed immediately after the callback completes, regardless of success or failure.
+     *
+     * @template T The type of the sensitive value.
+     * @template R The resolved type of the callback function's Promise.
+     * @param {Secret<T>} secret The Secret instance to operate on.
+     * @param {(value: T) => Promise<R>} callback The asynchronous function to execute with the revealed value.
+     * @returns {Promise<R>} A Promise that resolves to the result of the asynchronous callback.
+     */
+    static disposeAsync<T, R>(secret: Secret<T>, callback: (value: T) => Promise<R>): Promise<R>;
+    /**
+     * Prevents accidental serialization of the secret value via `JSON.stringify()`.
+     * @throws {SecretError} Always throws an error to prevent serialization.
+     */
+    toJSON(): void;
+    /**
+     * Prevents accidental string conversion of the secret value.
+     * @throws {SecretError} Always throws an error to prevent conversion.
+     */
+    toString(): void;
+    /**
+     * Prevents accidental primitive conversion of the secret value.
+     * @throws {SecretError} Always throws an error to prevent conversion.
+     */
+    valueOf(): void;
+    /**
+     * Prevents accidental primitive conversion of the secret value, respecting the `hint`.
+     * @param {'string' | 'number' | 'default'} hint The desired conversion hint.
+     * @throws {SecretError} Always throws an error to prevent conversion.
+     */
+    [Symbol.toPrimitive](hint: 'string' | 'number' | 'default'): void;
+    /**
+     * Prevents accidental inspection via `Object.prototype.toString.call()`.
+     * @throws {SecretError} Always throws an error to prevent inspection.
+     */
+    get [Symbol.toStringTag](): void;
+    /**
+     * Implements the `[Symbol.dispose]` method, making the Secret compatible with
+     * the TypeScript 5.2+ `using` declaration for automatic resource management.
+     *
+     * When a `using` block exits, this method is called, which internally calls `destroy`.
+     * @internal
+     */
+    [Symbol.dispose](): void;
+}

package/dist/types/Other/stack.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A LIFO (Last-In-First-Out) stack implementation
+ * @template T The type of elements stored in the stack
+ * @note It is recommended not to store `null` values in this stack, as `null` is used
+ * by `peek()` and `pop()` to indicate an empty stack.
+ * Storing `null` makes it impossible to distinguish between "stack is empty" and "actual null value stored".
+ */
+export declare class Stack<T> {
+    private stack_data;
+    /**
+     * Returns the number of elements in the stack
+     */
+    get size(): number;
+    /**
+     * Checks if the stack is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the top element without removing it
+     * @returns The top element, or null if stack is empty
+     */
+    peek(): T | null;
+    /**
+     * Pushes an element onto the top of the stack
+     */
+    push(item: T): void;
+    /**
+     * Removes and returns the top element from the stack
+     * @returns The top element, or null if stack is empty
+     */
+    pop(): T | null;
+    /**
+     * Removes all elements from the stack
+     */
+    clear(): void;
+    /**
+     * Converts the stack to an array (top element at the end)
+     */
+    toArray(): T[];
+}

package/dist/types/Reactive/__export__.d.ts

@@ -0,0 +1,4 @@
+export * from './flow';
+export * from './flow-combination';
+export * from './pace';
+export * from './event_emitter';

package/dist/types/Reactive/event_emitter.d.ts

@@ -0,0 +1,195 @@
+type Callback<T extends Record<string, unknown[]>, K extends keyof T> = (...args: T[K]) => void;
+/**
+ * A type-safe event emitter that supports synchronous and asynchronous event handling.
+ *
+ * Features:
+ * - Full TypeScript type safety with event map support
+ * - Special events: `newListener`, `removeListener`, `error`
+ * - Supports prepend/once/async patterns
+ * - Deferred listener modification during emit (prevents iteration issues)
+ * - Optimized storage: single function -> list transition
+ *
+ * @template T - Event map where keys are event names and values are argument tuples
+ *
+ * @example
+ * ```ts
+ * interface MyEvents {
+ *   message: [text: string, from: string];
+ *   data: [payload: unknown];
+ *   error: [err: Error];
+ * }
+ *
+ * const emitter = new EventEmitter<MyEvents>();
+ * emitter.on('message', (text, from) => console.log(`${from}: ${text}`));
+ * emitter.emit('message', 'Hello', 'Alice');
+ * ```
+ */
+export declare class EventEmitter<T extends Record<PropertyKey, unknown[]>> {
+    private events;
+    private emitting_depth;
+    private pending_removals_set;
+    private pending_removals_list;
+    private pending_additions;
+    /**
+     * Creates a new EventEmitter instance.
+     */
+    constructor();
+    private emitRemoveListener;
+    /**
+     * Registers an event listener that will be invoked each time the event is emitted.
+     *
+     * Triggers `newListener` event before adding the listener.
+     * During an active emit, additions are deferred until the emit completes.
+     *
+     * @template K - Event name key
+     * @param event - The event name to listen for
+     * @param callback - The listener function to register
+     * @returns This EventEmitter instance for chaining
+     */
+    on<K extends keyof T>(event: K, callback: Callback<T, K>): this;
+    /**
+     * Removes a previously registered event listener.
+     *
+     * Triggers `removeListener` event after removing the listener.
+     * During an active emit, removals are deferred until the emit completes.
+     *
+     * @template K - Event name key
+     * @param event - The event name to remove the listener from
+     * @param callback - The listener function to remove
+     * @returns This EventEmitter instance for chaining
+     */
+    off<K extends keyof T>(event: K, callback: Callback<T, K>): this;
+    private findWrappedFn;
+    private removeFromList;
+    /**
+     * Emits an event, invoking all registered listeners with the provided arguments.
+     *
+     * Listeners are invoked in order: prepend listeners (reverse order) then normal listeners.
+     * If no listeners exist and the event is `error`, the error is thrown.
+     * Listener errors are caught and forwarded to `error` event handlers.
+     *
+     * @template K - Event name key
+     * @param event - The event name to emit
+     * @param args - Arguments to pass to the listeners
+     * @returns `true` if all listeners completed without errors, `false` otherwise
+     * @throws The error argument if emitting `error` with no listeners
+     */
+    emit<K extends keyof T>(event: K, ...args: T[K]): boolean;
+    private handleEmitError;
+    private isPendingRemoval;
+    private flushPendingOperations;
+    /**
+     * Registers a one-time listener that removes itself after first invocation.
+     *
+     * @template K - Event name key
+     * @param event - The event name to listen for
+     * @param callback - The listener function to register
+     * @returns This EventEmitter instance for chaining
+     */
+    once<K extends keyof T>(event: K, callback: Callback<T, K>): this;
+    /**
+     * Registers a listener that will be invoked before other listeners.
+     *
+     * Prepend listeners are invoked in reverse order of registration (LIFO).
+     * Triggers `newListener` event before adding the listener.
+     *
+     * @template K - Event name key
+     * @param event - The event name to listen for
+     * @param callback - The listener function to register
+     * @returns This EventEmitter instance for chaining
+     */
+    prependListener<K extends keyof T>(event: K, callback: Callback<T, K>): this;
+    /**
+     * Registers a one-time prepend listener.
+     *
+     * Combines `prependListener` and `once` behavior.
+     *
+     * @template K - Event name key
+     * @param event - The event name to listen for
+     * @param callback - The listener function to register
+     * @returns This EventEmitter instance for chaining
+     */
+    prependOnceListener<K extends keyof T>(event: K, callback: Callback<T, K>): this;
+    /**
+     * Returns the number of listeners registered for the specified event.
+     *
+     * @param event - The event name to query
+     * @returns The count of registered listeners
+     */
+    listenerCount(event: keyof T): number;
+    /**
+     * Returns a copy of the listeners array for the specified event.
+     *
+     * @template K - Event name key
+     * @param event - The event name to query
+     * @returns Array of registered listener functions
+     */
+    listeners<K extends keyof T>(event: K): Callback<T, K>[];
+    /**
+     * Returns an array of event names that have registered listeners.
+     *
+     * @returns Array of event names with at least one listener
+     */
+    eventNames(): (keyof T)[];
+    /**
+     * Removes all listeners for a specific event, or all listeners if no event is specified.
+     *
+     * Triggers `removeListener` event for each removed listener.
+     * During an active emit, removals are deferred until the emit completes.
+     *
+     * @param event - Optional event name to remove listeners from
+     * @returns This EventEmitter instance for chaining
+     */
+    removeAllListeners(event?: keyof T): this;
+    /**
+     * Asynchronously emits an event, awaiting all listener results.
+     *
+     * All listeners are executed in parallel using `Promise.all`.
+     * Listener errors are collected and thrown as `AggregateError` if multiple,
+     * or re-thrown directly if only one error occurred.
+     *
+     * @template K - Event name key
+     * @param event - The event name to emit
+     * @param args - Arguments to pass to the listeners
+     * @returns Promise resolving to `true` if all listeners succeeded
+     * @throws The error argument if emitting `error` with no listeners
+     * @throws AggregateError if multiple listeners threw errors
+     */
+    emitAsync<K extends keyof T>(event: K, ...args: T[K]): Promise<boolean>;
+    private handleAsyncError;
+    /**
+     * Returns a promise that resolves when the specified event is emitted.
+     *
+     * Supports timeout, filter function, and AbortSignal for cancellation.
+     *
+     * @template K - Event name key
+     * @param event - The event name to wait for
+     * @param options - Optional configuration
+     * @param options.timeout - Maximum time to wait in milliseconds
+     * @param options.filter - Function to filter which emissions to accept
+     * @param options.signal - AbortSignal for cancellation
+     * @returns Promise resolving to the event arguments tuple
+     * @throws Error on timeout
+     * @throws DOMException when aborted via signal
+     */
+    waitFor<K extends keyof T>(event: K, options?: {
+        timeout?: number;
+        filter?: (...args: T[K]) => boolean;
+        signal?: AbortSignal;
+    }): Promise<T[K]>;
+    /**
+     * Alias for `waitFor` without filter support.
+     *
+     * @template K - Event name key
+     * @param event - The event name to wait for
+     * @param options - Optional configuration
+     * @param options.timeout - Maximum time to wait in milliseconds
+     * @param options.signal - AbortSignal for cancellation
+     * @returns Promise resolving to the event arguments tuple
+     */
+    onceAsync<K extends keyof T>(event: K, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T[K]>;
+}
+export {};

package/dist/types/Reactive/flow-combination.d.ts

@@ -0,0 +1,74 @@
+import { Flow, Observer, Unsubscribable } from './flow';
+type FlowInputValue<T> = T extends FlowInput<infer R> ? R : never;
+type FlowInputTuple<T extends readonly FlowInput<unknown>[]> = {
+    [K in keyof T]: FlowInputValue<T[K]>;
+};
+type PrependTuple<T, R extends readonly unknown[]> = [T, ...R];
+interface FlowInput<T> {
+    subscribe(observer: Observer<T>): Unsubscribable;
+}
+/**
+ * Merges multiple Flow sources into a single Flow that emits values
+ * from all sources concurrently. Completes when all sources complete.
+ * @template T The value type emitted by the sources
+ * @param sources Flow sources to merge
+ * @returns A Flow emitting values from all sources as they arrive
+ */
+export declare function mergeFlow<T>(...sources: [FlowInput<T>, ...FlowInput<T>[]]): Flow<T>;
+/**
+ * Concatenates multiple Flow sources sequentially, subscribing to each
+ * source only after the previous one completes.
+ * @template T The value type emitted by the sources
+ * @param sources Flow sources to concatenate
+ * @returns A Flow emitting values from each source in order
+ */
+export declare function concatFlow<T>(...sources: [FlowInput<T>, ...FlowInput<T>[]]): Flow<T>;
+/**
+ * Races multiple Flow sources, emitting the first value, error, or completion
+ * from any source and immediately unsubscribing from all others.
+ * @template T The value type emitted by the sources
+ * @param sources Flow sources to race
+ * @returns A Flow mirroring the first source to emit
+ */
+export declare function raceFlow<T>(...sources: [FlowInput<T>, ...FlowInput<T>[]]): Flow<T>;
+/**
+ * Combines multiple Flow sources to emit tuples of the latest values
+ * from all sources whenever any source emits. Waits for all sources
+ * to emit at least once before emitting.
+ * @template T A tuple type of Flow sources
+ * @param sources Flow sources to combine
+ * @returns A Flow emitting tuples of the latest values from all sources
+ */
+export declare function combineLatestFlow<T extends readonly [FlowInput<unknown>, ...FlowInput<unknown>[]]>(...sources: T): Flow<FlowInputTuple<T>>;
+/**
+ * Combines a source Flow with other Flows, emitting a tuple of the source value
+ * and the latest values from other sources whenever the source emits.
+ * Waits for all other sources to emit at least once.
+ * @template T The value type emitted by the main source
+ * @template R A tuple type of other Flow sources
+ * @param source The main Flow that triggers emissions
+ * @param others Other Flow sources to combine with
+ * @returns A Flow emitting tuples with the source value prepended to other values
+ */
+export declare function withLatestFromFlow<T, R extends readonly [FlowInput<unknown>, ...FlowInput<unknown>[]]>(source: FlowInput<T>, ...others: R): Flow<PrependTuple<T, FlowInputTuple<R>>>;
+/**
+ * Waits for all Flow sources to complete, then emits a tuple of their last values.
+ * Emits once when all sources complete. Completes without emitting if any
+ * source completes without emitting.
+ * @template T A tuple type of Flow sources
+ * @param sources Flow sources to join
+ * @returns A Flow emitting a single tuple of last values when all sources complete
+ */
+export declare function forkJoinFlow<T extends readonly [FlowInput<unknown>, ...FlowInput<unknown>[]]>(...sources: T): Flow<FlowInputTuple<T>>;
+/**
+ * Zips multiple Flow sources by index, emitting tuples containing the nth
+ * value from each source. Completes when any source completes and its
+ * buffer is empty.
+ * @template T A tuple type of Flow sources
+ * @param sources Flow sources to zip
+ * @returns A Flow emitting tuples of values at the same index from each source
+ */
+export declare function zipFlow<T extends readonly [FlowInput<unknown>, ...FlowInput<unknown>[]]>(...sources: T): Flow<{
+    [K in keyof T]: T[K] extends FlowInput<infer R> ? R : never;
+}>;
+export {};