import type EventEmitter from "events";
import type { ActionHandler, ActionHandlerRecord } from "./flux";
export declare enum DispatchBand {
    Early = 0,
    Database = 1,
    Default = 2
}
interface Action {
    type: string;
    [key: string]: any;
}
type ActionMetric = [string, string, number];
export declare class ActionLogger extends EventEmitter {
    constructor(data?: {
        persist: boolean;
    });
    persist: boolean;
    logs: ActionLog[];
    getLastActionMetrics: (name: string, limit?: number) => ActionMetric[];
    getSlowestActions: (type: string, limit?: number) => ActionMetric[];
    log: (action: Action, callback: (func: (name: string, dispatchFunc: unknown) => boolean | undefined) => void) => ActionLog;
}
interface Trace {
    name: string;
    time: number;
}
declare class ActionLog {
    constructor(action: Action);
    action: Action;
    createdAt: Date;
    id: number;
    startTime: number;
    totalTime: number;
    traces: Trace[];
    get name(): string;
    toJSON: () => {
        actionType: string;
        created_at: Date;
        totalTime: number;
        traces: Trace[];
    };
}
interface NodeData {
    actionHandler: ActionHandlerRecord;
    band: DispatchBand;
    name: string;
    storeDidChange: (action: Action) => void;
}
export declare class DepGraph {
    constructor(opts?: {
        circular?: boolean;
    });
    nodes: Record<string, {
        name: string;
    }>;
    outgoingEdges: Record<string, string[]>;
    incomingEdges: Record<string, string[]>;
    circular: boolean | undefined;
    size: () => number;
    addNode: (name: string, data?: NodeData) => void;
    removeNode: (name: string) => void;
    hasNode: (name: string) => boolean;
    getNodeData: (name: string) => NodeData;
    setNodeData: (name: string, data: NodeData) => void;
    addDependency: (from: string, to: string) => boolean;
    removeDependency: (from: string, to: string) => void;
    clone: () => DepGraph;
    dependenciesOf: (name: string, leavesOnly?: boolean) => string[];
    dependantsOf: (name: string, leavesOnly?: boolean) => string[];
    overallOrder: (leavesOnly?: boolean) => string[];
}
interface Handler {
    actionHandler: ActionHandler;
    name: string;
    storeDidChange: (action: Action) => void;
}
declare class ActionHandlersGraph {
    _orderedActionHandlers: Record<string, Handler[]>;
    _orderedCallbackTokens: string[];
    _lastID: number;
    _dependencyGraph: DepGraph;
    addDependencies: (token: string, tokens: string) => void;
    createToken: () => string;
    getOrderedActionHandlers: (action: Action) => Handler[];
    register: (name: string, actionHandlers: ActionHandlerRecord, storeDidChange: (action: Action) => void, band: DispatchBand, token?: string) => string;
    private _addToBand;
    private _bandToken;
    private _computeOrderedActionHandlers;
    private _computeOrderedCallbackTokens;
    private _invalidateCaches;
    private _validateDependencies;
}
interface Breadcrumb {
    category?: string;
    data?: Record<string, unknown>;
    message?: string;
}
interface SentryUtils {
    addBreadcrumb: (breadcrumb: Breadcrumb) => void;
}
export interface FluxDispatcher {
    _actionHandlers: ActionHandlersGraph;
    _currentDispatchActionType: string | null;
    _defaultBand: DispatchBand;
    _interceptors: Array<(...rest: unknown[]) => unknown>;
    _processingWaitQueue: boolean;
    _sentryUtils: SentryUtils | null | undefined;
    _subscriptions: Record<string, Set<ActionHandler>>;
    _waitQueue: Array<(...rest: unknown[]) => unknown>;
    actionLogger: ActionLogger;
    functionCache: Record<string, (action: Action) => void>;
    _dispatchWithDevtools: (action: Action) => void;
    _dispatchWithLogging: (action: Action) => void;
    _dispatch: (action: Action, func: (name: string, dispatchFunc: unknown) => boolean | undefined) => boolean | undefined;
    addDependencies: (token: string, tokens: string[]) => void;
    addInterceptor: (callback: (...rest: unknown[]) => unknown) => void;
    createToken: () => string;
    dispatch: (action: Action) => void;
    flushWaitQueue: () => void;
    isDispatching: () => boolean;
    subscribe: <A extends Action>(type: string, callback: ActionHandler<A>) => void;
    unsubscribe: <A extends Action>(type: string, callback: ActionHandler<A>) => void;
    wait: (callback: (...rest: unknown[]) => unknown) => void;
    register: (name: string, actionHandlers: ActionHandlerRecord, storeDidChange: (action: Action) => void, band: DispatchBand, token?: string) => string;
}
declare const _default: FluxDispatcher;
export default _default;