okta-mcp-server/dist/core/event-bus.d.ts

Model Context Protocol (MCP) server for Okta API operations with support for bulk operations and caching

/**
 * Type-safe event bus for event-driven architecture
 */
export type EventHandler<T = any> = (data: T) => void | Promise<void>;
export interface EventMap {
    [event: string]: any;
}
export interface OktaEventMap extends EventMap {
    'server:started': {
        config: any;
    };
    'server:stopping': {};
    'server:stopped': {};
    'server:error': {
        error: any;
    };
    'tools:list': {
        request: any;
    };
    'tools:call': {
        name: string;
        args: any;
        request: any;
    };
    'resources:list': {
        request: any;
    };
    'resources:read': {
        uri: string;
        request: any;
    };
    'okta:request': {
        method: string;
        path: string;
    };
    'okta:response': {
        method: string;
        path: string;
        status: number;
        duration: number;
    };
    'okta:error': {
        method: string;
        path: string;
        error: any;
    };
    'cache:hit': {
        key: string;
    };
    'cache:miss': {
        key: string;
    };
    'cache:set': {
        key: string;
        ttl?: number;
    };
    'cache:clear': {
        pattern?: string;
    };
    'cache:cleanup': {
        deleted: number;
    };
    'cache:error': {
        error: any;
        key?: string;
        tag?: string;
    };
    'audit:logged': {
        entry: any;
    };
    'audit:cleanup': {
        deleted: number;
    };
    'audit:error': {
        error: any;
    };
}
export declare class EventBus<T extends EventMap = OktaEventMap> {
    private handlers;
    private asyncHandlers;
    /**
     * Subscribe to an event
     */
    on<K extends keyof T>(event: K, handler: EventHandler<T[K]>): () => void;
    /**
     * Subscribe to an event (alias for on)
     */
    subscribe<K extends keyof T>(event: K, handler: EventHandler<T[K]>): () => void;
    /**
     * Subscribe to an event once
     */
    once<K extends keyof T>(event: K, handler: EventHandler<T[K]>): () => void;
    /**
     * Unsubscribe from an event
     */
    off<K extends keyof T>(event: K, handler: EventHandler<T[K]>): void;
    /**
     * Emit an event synchronously
     */
    emit<K extends keyof T>(event: K, data: T[K]): void;
    /**
     * Emit an event asynchronously
     */
    emitAsync<K extends keyof T>(event: K, data: T[K]): Promise<void>;
    /**
     * Register an async event handler
     */
    onAsync<K extends keyof T>(event: K, handler: EventHandler<T[K]>): () => void;
    /**
     * Wait for an event to occur
     */
    waitFor<K extends keyof T>(event: K, timeout?: number): Promise<T[K]>;
    /**
     * Clear all event handlers
     */
    clear(): void;
    /**
     * Get the number of handlers for an event
     */
    listenerCount<K extends keyof T>(event: K): number;
    /**
     * Get all registered events
     */
    eventNames(): (keyof T)[];
}
//# sourceMappingURL=event-bus.d.ts.map