import { subscribe as originalSubscribe, publish as originalPublish, once as originalOnce, waitFor as originalWaitFor, hasEventSubscriptions, reset, EventCallback, ApiCallback, PublishResponse } from './eventBus';
/**
 * Re-export existing EventBus functionality
 */
export { hasEventSubscriptions, reset, type EventCallback, type ApiCallback, type PublishResponse, };
/**
 * Enhanced subscribe that maintains backward compatibility
 */
export declare const subscribe: typeof originalSubscribe;
export declare const publish: typeof originalPublish;
export declare const once: typeof originalOnce;
export declare const waitFor: typeof originalWaitFor;
declare class AsyncEventIterator<T = ApiCallback> {
    private subscription;
    private unsubscribe;
    private eventType;
    constructor(eventType: string);
    next(): Promise<IteratorResult<T>>;
    return(): Promise<IteratorResult<T>>;
    throw(error: Error): Promise<IteratorResult<T>>;
    [Symbol.asyncIterator](): this;
}
/**
 * Create an async iterator for an event type
 *
 * @example
 * ```typescript
 * for await (const message of iterate("user.events")) {
 *   console.log("Received:", message);
 * }
 * ```
 */
export declare function iterate<T = ApiCallback>(eventType: string): AsyncEventIterator<T>;
/**
 * Create an async generator that yields events
 *
 * @example
 * ```typescript
 * for await (const message of stream("user.events")) {
 *   console.log("Received:", message);
 * }
 * ```
 */
export declare function stream<T = ApiCallback>(eventType: string, options?: {
    filter?: (msg: T) => boolean;
    transform?: (msg: T) => any;
    bufferSize?: number;
}): AsyncGenerator<T, void, unknown>;
/**
 * Create a filtered stream of events
 */
export declare function filter<T = ApiCallback>(eventType: string, predicate: (msg: T) => boolean): AsyncGenerator<T, void, unknown>;
/**
 * Map/transform events in a stream
 */
export declare function map<T = ApiCallback, R = any>(eventType: string, transform: (msg: T) => R): AsyncGenerator<R, void, unknown>;
/**
 * Batch events with time window or count limit
 */
export declare function batch<T = ApiCallback>(eventType: string, options?: {
    maxSize?: number;
    maxWait?: number;
}): AsyncGenerator<T[], void, unknown>;
/**
 * Merge multiple event streams
 */
export declare function merge<T = ApiCallback>(...eventTypes: string[]): AsyncGenerator<{
    eventType: string;
    message: T;
}, void, unknown>;
/**
 * Process events with backpressure control
 */
export declare function processWithBackpressure<T = ApiCallback>(eventType: string, processor: (msg: T) => Promise<void>, maxConcurrent?: number): Promise<void>;
/**
 * Take only the first N events
 */
export declare function take<T = ApiCallback>(eventType: string, count: number): AsyncGenerator<T, void, unknown>;
/**
 * Skip the first N events
 */
export declare function skip<T = ApiCallback>(eventType: string, count: number): AsyncGenerator<T, void, unknown>;
/**
 * Debounce events (only emit after a period of inactivity)
 */
export declare function debounce<T = ApiCallback>(eventType: string, delay: number): AsyncGenerator<T, void, unknown>;
/**
 * Throttle events (limit emission rate)
 */
export declare function throttle<T = ApiCallback>(eventType: string, interval: number): AsyncGenerator<T, void, unknown>;
/**
 * Combine latest values from multiple event streams
 */
export declare function combineLatest<T = ApiCallback>(...eventTypes: string[]): AsyncGenerator<Record<string, T | undefined>, void, unknown>;
//# sourceMappingURL=async-event-bus.d.ts.map