import { Args, RemeshCommandAction, RemeshDomain, RemeshDomainDefinition, RemeshEventAction, Serializable } from './remesh';
import type { RemeshDomainStorage, RemeshQueryStorage, RemeshStateStorage, RemeshStoreOptions } from './store';
export type RemeshDomainStorageEventData<T extends RemeshDomainDefinition, U extends Args<Serializable>> = {
    type: 'Domain::Created' | 'Domain::Discarded' | 'Domain::Reused';
    storage: RemeshDomainStorage<T, U>;
};
export type RemeshStateStorageEventData<T> = {
    type: 'State::Created' | 'State::Updated' | 'State::Discarded' | 'State::Reused';
    storage: RemeshStateStorage<T>;
};
export type RemeshQueryStorageEventData<T extends Args<Serializable>, U> = {
    type: 'Query::Created' | 'Query::Updated' | 'Query::Discarded' | 'Query::Reused';
    storage: RemeshQueryStorage<T, U>;
};
export type RemeshEventEmittedEventData<T extends Args, U> = {
    type: 'Event::Emitted';
    action: RemeshEventAction<T, U>;
};
export type RemeshCommandReceivedEventData<T extends Args> = {
    type: 'Command::Received';
    action: RemeshCommandAction<T>;
};
export declare const InspectorType: {
    readonly DomainCreated: "Domain::Created";
    readonly DomainDiscarded: "Domain::Discarded";
    readonly DomainReused: "Domain::Reused";
    readonly StateCreated: "State::Created";
    readonly StateUpdated: "State::Updated";
    readonly StateDiscarded: "State::Discarded";
    readonly StateReused: "State::Reused";
    readonly QueryCreated: "Query::Created";
    readonly QueryUpdated: "Query::Updated";
    readonly QueryDiscarded: "Query::Discarded";
    readonly QueryReused: "Query::Reused";
    readonly EventEmitted: "Event::Emitted";
    readonly CommandReceived: "Command::Received";
};
export declare const RemeshInspectorDomain: RemeshDomain<{
    command: {
        RemeshDomainStorageCommand: import("./remesh").RemeshCommand<[event: RemeshDomainStorageEventData<any, any>]>;
        RemeshStateStorageCommand: import("./remesh").RemeshCommand<[event: RemeshStateStorageEventData<any>]>;
        RemeshQueryStorageCommand: import("./remesh").RemeshCommand<[event: RemeshQueryStorageEventData<any, any>]>;
        RemeshEventEmittedCommand: import("./remesh").RemeshCommand<[event: RemeshEventEmittedEventData<any, any>]>;
        RemeshCommandReceivedCommand: import("./remesh").RemeshCommand<[event: RemeshCommandReceivedEventData<any>]>;
    };
    event: {
        RemeshDomainStorageEvent: import("./remesh").RemeshEvent<[RemeshDomainStorageEventData<any, any>], RemeshDomainStorageEventData<any, any>>;
        RemeshStateStorageEvent: import("./remesh").RemeshEvent<[RemeshStateStorageEventData<any>], RemeshStateStorageEventData<any>>;
        RemeshQueryStorageEvent: import("./remesh").RemeshEvent<[RemeshQueryStorageEventData<any, any>], RemeshQueryStorageEventData<any, any>>;
        RemeshEventEmittedEvent: import("./remesh").RemeshEvent<[RemeshEventEmittedEventData<any, any>], RemeshEventEmittedEventData<any, any>>;
        RemeshCommandReceivedEvent: import("./remesh").RemeshEvent<[RemeshCommandReceivedEventData<any>], RemeshCommandReceivedEventData<any>>;
    };
}, []>;
export type InspectInput = {
    inspectable: boolean;
    owner?: {
        Domain: {
            inspectable: boolean;
        };
    };
};
export declare const isInspectable: (input: InspectInput) => boolean;
export declare const createInspectorManager: (options: RemeshStoreOptions) => {
    destroyInspectors: () => void;
    inspectDomainStorage: <T extends Partial<import("./remesh").RemeshDomainOutput>, U extends Args<Serializable>>(type: "Domain::Created" | "Domain::Discarded" | "Domain::Reused", domainStorage: RemeshDomainStorage<T, U>) => void;
    inspectStateStorage: <T_1>(type: "State::Created" | "State::Updated" | "State::Discarded" | "State::Reused", stateStorage: RemeshStateStorage<T_1>) => void;
    inspectQueryStorage: <T_2 extends Args<Serializable>, U_1>(type: "Query::Created" | "Query::Updated" | "Query::Discarded" | "Query::Reused", queryStorage: RemeshQueryStorage<T_2, U_1>) => void;
    inspectEventEmitted: <T_3 extends Args, U_2>(type: "Event::Emitted", eventAction: RemeshEventAction<T_3, U_2>) => void;
    inspectCommandReceived: <T_4 extends Args>(type: "Command::Received", commandAction: RemeshCommandAction<T_4>) => void;
};