@agentman/chat-widget/dist/assistantWidget/utils/EventBus.d.ts

Agentman Chat Widget for easy integration with web applications

export type EventHandler<T = any> = (data: T) => void | Promise<void>;
export interface EventSubscription {
    unsubscribe(): void;
}
/**
 * EventBus - Centralized event system for decoupled component communication
 *
 * Features:
 * - Type-safe event handling
 * - Async event support
 * - Automatic cleanup
 * - Debug logging
 * - Event history tracking
 */
export declare class EventBus {
    private listeners;
    private logger;
    private eventHistory;
    private maxHistorySize;
    constructor(debug?: boolean | import('../types/types').DebugConfig);
    /**
     * Emit an event to all registered listeners
     */
    emit<T = any>(event: string, data?: T): void;
    /**
     * Register an event listener
     */
    on<T = any>(event: string, handler: EventHandler<T>): EventSubscription;
    /**
     * Remove an event listener
     */
    off<T = any>(event: string, handler: EventHandler<T>): void;
    /**
     * Remove all listeners for an event
     */
    removeAllListeners(event?: string): void;
    /**
     * Get number of listeners for an event
     */
    getListenerCount(event: string): number;
    /**
     * Get all registered events
     */
    getRegisteredEvents(): string[];
    /**
     * Check if an event has listeners
     */
    hasListeners(event: string): boolean;
    /**
     * Get recent event history for debugging
     */
    getEventHistory(limit?: number): Array<{
        event: string;
        timestamp: number;
        data?: any;
    }>;
    /**
     * Clear event history
     */
    clearHistory(): void;
    /**
     * Add event to history for debugging
     */
    private addToHistory;
    /**
     * Determine if data should be logged (avoid logging sensitive info)
     */
    private shouldLogData;
    /**
     * Create a namespaced event bus (useful for components)
     */
    createNamespace(namespace: string): NamespacedEventBus;
    /**
     * Wait for a specific event to be emitted
     */
    waitForEvent<T = any>(event: string, timeout?: number): Promise<T>;
    /**
     * Emit event and wait for response
     */
    request<TRequest = any, TResponse = any>(requestEvent: string, responseEvent: string, data?: TRequest, timeout?: number): Promise<TResponse>;
    /**
     * Get debug information
     */
    getDebugInfo(): {
        totalEvents: number;
        totalListeners: number;
        events: Array<{
            event: string;
            listenerCount: number;
        }>;
        recentHistory: Array<{
            event: string;
            timestamp: number;
        }>;
    };
}
/**
 * Namespaced EventBus for component-specific events
 */
declare class NamespacedEventBus {
    private eventBus;
    private namespace;
    constructor(eventBus: EventBus, namespace: string);
    emit<T = any>(event: string, data?: T): void;
    on<T = any>(event: string, handler: EventHandler<T>): EventSubscription;
    off<T = any>(event: string, handler: EventHandler<T>): void;
    removeAllListeners(event?: string): void;
}
export declare const globalEventBus: EventBus;
export {};