export interface IExecutionEntry {
    key: string;
    args: unknown[];
}
/**
 * ExecutionQueue allows multiple handlers to be processed in real time or deferred.
 * @internal
 */
export default class ExecutionQueue {
    private _shouldExecuteInRealTime;
    private _handlers;
    private _executionEntries;
    /**
     * Determines if the added execution entries should be processed in real time.
     * If this is set to true, a stack with entries will not be saved.
     *
     * When set to true, all entries on stack will be processed and future entries
     * will be executed in real time.
     * When set to false, future entries will be saved in the execution stack for
     * later processing.
     */
    get shouldExecuteInRealTime(): boolean;
    set shouldExecuteInRealTime(executeInRealTime: boolean);
    /**
     * Registers an external handler to collection for delayed asynchronous processing.
     * Handlers are registered once. If handler is already registered, it does nothing.
     */
    addHandler(key: string, handler: (...args: unknown[]) => void): void;
    /**
     * Execution Entry registration for delayed asynchronous processing.
     */
    addExecutionEntry(key: string, ...args: unknown[]): void;
    /**
     * Removes an external executionEntry handler from collection for asynchronous event logging.
     * Logger is registered once.
     */
    removeHandler(key: string, handler: (...args: unknown[]) => void): void;
    /**
     * Reset function clears executionEntry handler collection for asynchronous event logging.
     * All recorded execution entries and handlers are purged.
     */
    reset(): void;
    /**
     * Flushes all the buffered execution entries.
     * All recorded execution entries are purged.
     */
    flush(): void;
    private _containsHandler;
    private _initializeHandlerArrayForKey;
    private _processAllExecutionEntries;
    private _processExecutionEntry;
}
//# sourceMappingURL=ExecutionQueue.d.ts.map