declare type ComputedEvent = {
    name: string;
    oldValue: unknown;
    newValue: unknown;
};
declare type ObservableEvent = {
    type: 'update';
    name: string;
    oldValue: unknown;
    newValue: unknown;
} | {
    type: 'array';
    name: string;
    added: unknown[];
    removed: unknown[];
} | {
    type: 'map';
    name: string;
    key: unknown;
    mapType: 'add' | 'delete' | 'update';
    value?: unknown;
    oldValue?: unknown;
} | {
    type: 'set';
    name: string;
    setType: 'add' | 'delete';
    value: unknown;
};
declare type ActionEvent = {
    name: string;
    arguments: unknown[];
};
declare type Logger = {
    logObservable(event: ObservableEvent): void;
    logAction(event: ActionEvent): void;
    logComputed(event: ComputedEvent): void;
};

declare type Config = {
    logger: Logger;
    debug: boolean;
    storeConsoleAccess: boolean;
    filters: {
        computeds: boolean;
        actions: boolean;
        observables: boolean;
    };
};
declare type LoggerOptions = Partial<Pick<Config, 'logger' | 'debug' | 'storeConsoleAccess' | 'filters'>>;
declare const configureLogger: (options?: LoggerOptions) => void;

declare type StoreEventFilters = {
    computeds: boolean;
    observables: boolean;
    actions: boolean;
};

declare type Css = {
    style: string;
};
declare type Chunk = [string, Css, string];
declare type Header = [string, Chunk, [string, string]];
declare type Body = [string, Css, ...any[]];
declare type ChromeFormatter<T> = {
    header: (argument: T) => Header | null;
    hasBody: (argument: T) => boolean;
    body: (argument: T) => Body;
};
declare const installMobxFormatters: () => void;

declare global {
    interface Window {
        devtoolsFormatters: ChromeFormatter<any>[];
        store?: Record<string, object | Array<object>>;
    }
}
declare type PerStoreFilters = {
    filters: {
        events: StoreEventFilters;
    };
};
declare const makeLoggable: <T extends {}>(store: T, perStoreConfig?: PerStoreFilters) => T;

declare type LogWriter = {
    write: (...messages: unknown[]) => void;
};
declare class DefaultLogWriter implements LogWriter {
    write(...messages: unknown[]): void;
}

declare class DefaultLogger implements Logger {
    private logWriter;
    constructor(logWriter: LogWriter);
    logObservable(event: ObservableEvent): void;
    logAction(event: ActionEvent): void;
    logComputed(event: ComputedEvent): void;
}

declare const useMakeLoggable: (store: any, name?: string) => void;

export { ActionEvent, ComputedEvent, DefaultLogWriter, DefaultLogger, Logger, ObservableEvent, installMobxFormatters as applyFormatters, configureLogger, makeLoggable, useMakeLoggable };