/**
 * These are to support legacy exports (see notes below).
 */
import { BaseService as baseService } from "./services/baseService";
import { _BaseClient } from "./deprecated/baseClient";
import UserNotification from "./common/toast";
import * as Util from "./common/util";
import DependencyManager from "./common/dependencyManager";
import { System } from "./common/system";
/**
 * Imports
 */
import { FEAGlobals } from "./common/Globals";
import { FSBLDesktop } from "./clients/Startup/FSBLDesktop";
import { FEA } from "./FEA";
import { FinsembleWindow } from "./common/FinsembleWindow";
import { DesktopAgent } from "./typedefs/FDC3/index";
export * as services from "./services";
export * as clients from "./clients";
export * as types from "./types";
/**
 * @internal Don't display FEA in Typedoc output
 */
export * as FEA from "./FEA";
export * as common from "./common";
export * as deprecated from "./deprecated";
export * as constants from "./common/constants";
export * from "./clients";
export * from "./common";
export * from "./types";
/**
 * Declare global variables that are injected either by preloads or by the FSBL library itself.
 */
declare global {
    /**
     * FSBL is declared as "let" because we sometimes set FSBL.debug to true.
     * This is type FSBLDesktop though in freestanding apps and services this isn't accurate.
     * Use of ambient types should be avoided in those use cases. FSBL is added through
     * the finsemble-desktop-api-preload (FSBL.js) that is preloaded by Launcher.
     */
    let FSBL: typeof FEAGlobals.FSBL;
    /**
     * The fin object is injected by FEA. Sometimes it's referred to as e2o.
     */
    const fin: typeof FEAGlobals.fin;
    /**
     * finsembleWindow is created on the fly by the FSBL client API initialization code.
     */
    const finsembleWindow: typeof FEAGlobals.finsembleWindow;
    /**
     * fdc3 is created on the fly by FSBLDesktop.
     */
    const fdc3: typeof FEAGlobals.fdc3;
}
/**
 * Wait, didn't we just declare these? Yes, as globals:
 *
 * Example
 *  ```
 * FSBL.Clients.RouterClient...
 * ```
 *
 * but they don't exist on the `window` object. These following definitions are necessary to make this work:
 *
 * Example
 * ```
 * window.FSBL.Clients.RouterClient...
 * ```
 */
declare global {
    interface Window {
        /**
         * FSBL is declared as "let" because we sometimes set FSBL.debug to true.
         * This is type FSBLDesktop though in freestanding apps and services this isn't accurate.
         * Use of ambient types should be avoided in those use cases. FSBL is added through
         * the finsemble-desktop-api-preload (FSBL.js) that is preloaded by Launcher.
         */
        FSBL: FSBLDesktop;
        /**
         * The fin object is injected by FEA. Sometimes it's referred to as e2o.
         */
        fin: FEA;
        /**
         * finsembleWindow is created on the fly by the FSBL client API initialization code.
         */
        finsembleWindow: FinsembleWindow;
        /**
         * fdc3 is created on the fly by FSBLDesktop.
         */
        fdc3: DesktopAgent;
    }
}
/**
 * Legacy ambient types
 *
 * These are types that are used in the client APIs and which previously
 * exported as root level ambient types. Customers that wrote typescript
 * code may have been using these types.
 */
export { WindowIdentifier, WindowDescriptor, WindowLocator, SpawnParams, ShowWindowParams, } from "./services/window/types";
export { WindowBounds } from "./services/window/types";
export { WorkspaceEventName } from "./services/workspace/types";
export { WindowEventName, WrapState } from "./services/window/types";
/**
 * Following are legacy exports that have been used by customers primarily to build custom
 * services and storage adapters. These will be deprecated over time as we roll out simplified
 * mechanisms for services and adapters.
 */
/**
 * Used for build storage adapters
 */
export declare const models: {
    baseStorage: (this: import("./services/storage/adapters/types").IBaseStorage, args: string) => void;
};
/**
 * @ignore Don't display these in Typedoc output
 */
export { FinsembleWindow, baseService, UserNotification, DependencyManager, System, Util };
export declare const Clients: {
    RouterClient: {
        onReady: (cb?: (() => void) | undefined) => Promise<void>;
        addListener: <T = any>(channel: string, eventHandler: import("./clients/routerClient").ListenerCallback<T>) => import("./clients/routerClient").RouterListenerUnsubscribe;
        transmit: <T_1 = any>(toChannel: string, data: T_1, options?: {
            suppressWarnings: boolean;
        } | undefined) => void;
        removeListener: (channel: string, eventHandler: Function) => void;
        addResponder: <Q = any, R = any>(channel: string, queryEventHandler: import("./types").StandardErrorCallback<import("./clients/routerClient").ResponderMessage<Q, R>>) => void;
        query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
            timeout?: number | undefined;
            logWhenNoResponder?: boolean | undefined;
        } | import("./clients/routerClient").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./clients/routerClient").QueryResponseCallback<R_1> | undefined) => Promise<import("./clients/routerClient").StandardQueryResponse<R_1>>;
        removeResponder: (responderChannel: string) => void;
        addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
            subscribeCallback?: import("./clients/routerClient").SubscribeCallback<T_2> | undefined;
            unsubscribeCallback?: import("./clients/routerClient").UnsubscribeCallback | undefined;
            publishCallback?: import("./clients/routerClient").PublishCallback<T_2> | undefined;
        } | undefined, callback?: ((err?: string | Error | undefined, result?: "success" | undefined) => void) | undefined) => void;
        removePubSubResponder: (topic: string | RegExp) => void;
        subscribe: <T_3 = any>(topic: string, notifyCallback: (err: import("./types").StandardError, response: import("./clients/routerClient").SubscriberResponse<T_3>) => void) => {
            subscribeID: string;
            topic: string;
        };
        publish: <T_4 = any>(topic: string, event: T_4) => void;
        unsubscribe: (subscribeIDStruct: {
            subscribeID: string;
            topic: string;
        }) => void;
        trustedMessage: (incomingMessage: import("./clients/routerClient").RouterMessage<any>) => boolean;
        disconnectAll: () => void;
        calibrateTimeWithRouterService(callback: (offset: number) => void): void;
    };
    StorageClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        clearCache: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        remove: (params: {
            key: string;
            topic: string;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        getMultiple: (params: any, cb?: import("./types").StandardErrorCallback<any> | undefined) => import("./types").StandardPromise<any>;
        keys: (params: {
            topic: string;
            keyPrefix?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<string[]> | undefined) => import("./types").StandardPromise<string[]>;
        getStandardized: <T_5 = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./types").StandardErrorCallback<T_5> | undefined) => import("./types").StandardPromise<T_5>;
        get: <T_6 = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./types").StandardErrorCallback<T_6> | undefined) => Promise<T_6>;
        save: (params: import("./services/window/WindowAbstractions/BaseWindow").ComponentMutateParams, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setStore: (params: {
            topic: string;
            dataStore?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setUser: (params: {
            user: string;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        delete: (...args: any[]) => void;
        remove1: (params: {
            key: string;
            topic: string;
        }) => void;
        get1: <T_7 = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./types").StandardErrorCallback<T_7> | undefined) => Promise<T_7>;
        save1: (params: {
            key: string;
            topic: string;
            value: any;
        }) => void;
        keys1: (params: {
            topic: string;
            keyPrefix?: string | undefined;
        }) => Promise<string[]>;
    };
    LauncherClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        addToGroups: (params: {
            windowIdentifier?: import("./services/window/types").WindowIdentifier | undefined;
            groupNames?: string[] | undefined;
        }, cb: (err?: import("./types").StandardError) => void) => Promise<{
            err: import("./types").StandardError;
        }>;
        getGroupsForWindow: (params: {
            windowIdentifier: import("./services/window/types").WindowIdentifier;
        } | null, cb?: Function) => Promise<unknown>;
        removeWindowsFromGroup: (params: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
        }, cb?: Function) => Promise<unknown>;
        addWindowsToGroup: (params: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
        }, cb?: Function) => Promise<unknown>;
        createWindowGroup: (params: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
        }, cb?: Function) => Promise<unknown>;
        minimizeWindows: (params: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
            componentType?: string | undefined;
        }, cb?: Function | undefined) => Promise<void>;
        hyperFocus: (params: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
            componentType?: string | undefined;
        }, cb?: (() => void) | undefined) => Promise<void>;
        bringWindowsToFront: (params?: {
            windowList?: string[] | import("./services/window/types").WindowIdentifier[] | undefined;
            groupName?: string | undefined;
            componentType?: string | undefined;
        }, cb?: Function) => Promise<void>;
        getComponentsThatCanReceiveDataTypes: (params: {
            dataTypes: string[];
        }, cb?: Function) => Promise<unknown>;
        removeUserDefinedComponent: (params: {
            name: string;
            url?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        addUserDefinedComponent: (params: {
            name: string;
            url: string;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        getPendingWindows: () => import("./types").StandardPromise<string[]>;
        getActiveAndPendingWindowNames: (cb?: Function) => Promise<{
            err: any;
            data: any;
        }>;
        getActiveDescriptors: (cb?: import("./types").StandardErrorCallback<Record<string, import("./services/window/types").WindowDescriptor>> | undefined) => import("./types").StandardPromise<Record<string, import("./services/window/types").WindowDescriptor>>;
        getMyWindowIdentifier: (cb?: ((windowIdentifier: import("./services/window/types").WindowIdentifier) => void) | undefined) => Promise<import("./services/window/types").WindowIdentifier>;
        getMonitor: (windowIdentifier: import("./services/window/types").WindowIdentifier, cb?: import("./types").StandardErrorCallback<any> | undefined) => import("./types").StandardPromise<any>;
        spawn: (component: string, params: import("./services/window/types").SpawnParams, cb?: import("./types").StandardErrorCallback<import("./clients/launcherClient").SpawnResponse> | undefined) => Promise<{
            error?: import("./types").StandardError;
            response?: import("./clients/launcherClient").SpawnResponse | undefined;
        }>;
        toggleWindowOnClick: (element: HTMLElement, windowLocator: import("./services/window/types").WindowLocator, params: any) => void;
        showWindow: (windowLocator: import("./services/window/types").WindowLocator, params: any, cb?: import("./types").StandardErrorCallback<import("./clients/launcherClient").SpawnResponse> | undefined) => import("./types").StandardPromise<import("./clients/launcherClient").SpawnResponse>;
        unRegisterComponent: (params: {
            componentType: string;
        }, cb?: import("./types").StandardErrorCallback<string> | undefined) => import("./types").StandardPromise<string>;
        registerComponent: (params: {
            componentType: string;
            manifest: import("./clients/launcherClient").ComponentDescriptor;
        }, cb: import("./types").StandardErrorCallback<string>) => import("./types").StandardPromise<string>;
        getMonitorInfo: (params?: {
            monitor?: import("./common/Monitors").MonitorCommand | undefined;
            windowIdentifier?: import("./services/window/types").WindowIdentifier | undefined;
        }, cb?: import("./types").StandardErrorCallback<import("./FEA").MonitorInfoDetail> | undefined) => import("./types").StandardPromise<import("./FEA").MonitorInfoDetail>;
        getMonitorInfoAll: (cb?: import("./types").StandardErrorCallback<import("./FEA").MonitorInfoDetail[]> | undefined) => import("./types").StandardPromise<import("./FEA").MonitorInfoDetail[]>;
        getComponentDefaultConfig: (componentType: string, cb?: import("./types").StandardErrorCallback<import("./clients/launcherClient").ComponentDescriptor> | undefined) => import("./types").StandardPromise<import("./clients/launcherClient").ComponentDescriptor>;
        getComponentList: (cb?: import("./types").StandardErrorCallback<import("./clients/launcherClient").ComponentList> | undefined) => import("./types").StandardPromise<import("./clients/launcherClient").ComponentList>;
    };
    DistributedStoreClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        createStore: (params: {
            store: string;
            global?: boolean | undefined;
            persist?: boolean | undefined;
            values?: any;
        }, cb?: import("./types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./types").StandardPromise<import("./types").StoreModel>;
        getStore: (params: {
            store: string;
            global?: boolean | undefined;
            waitForPersistentStoreToLoad?: boolean | undefined;
        }, cb?: import("./types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./types").StandardPromise<import("./types").StoreModel>;
        createGlobalStore: (params: {
            store: string;
            persist?: boolean | undefined;
            values?: any;
        }, cb?: import("./types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./types").StandardPromise<import("./types").StoreModel>;
        removeStore: (params: {
            store: string;
            global?: boolean | undefined;
        }, cb?: import("./types").StandardErrorCallback<boolean> | undefined) => import("./types").StandardPromise<boolean>;
    };
    LinkerClient: import("./deprecated/linkerClient").LinkerClient;
    WindowClient: {
        options: import("./FEA").WindowOptions;
        title: string | null;
        windowGroups: {
            windowNames: string[];
            isMovable: boolean;
            isAlwaysOnTop: boolean;
            topRightWindow: string;
            isARectangle: boolean;
        }[];
        commandChannel: ((arg0: any, arg1: any) => void) | undefined;
        fitToDOM: (params?: {
            padding?: {
                height: number;
                width: number;
            } | undefined;
            maxHeight?: number | undefined;
            maxWidth?: number | undefined;
        } | null | undefined, cb?: (() => void) | undefined) => Promise<void>;
        getBounds: (cb: import("./types").StandardErrorCallback<import("./services/window/types").Bounds>) => import("./types").StandardPromise<import("./services/window/types").Bounds>;
        getWindowGroups: () => {
            windowNames: string[];
            isMovable: boolean;
            isAlwaysOnTop: boolean;
            topRightWindow: string;
            isARectangle: boolean;
        }[];
        initialize: Function;
        onReady: Function;
        showAtMousePosition: () => void;
        getMonitorInfo: (params?: {
            monitor?: import("./common/Monitors").MonitorCommand | undefined;
            windowIdentifier?: import("./services/window/types").WindowIdentifier | undefined;
        }, cb?: import("./types").StandardErrorCallback<import("./FEA").MonitorInfoDetail> | undefined) => import("./types").StandardPromise<import("./FEA").MonitorInfoDetail>;
        getStackedWindow: (params?: import("./types").StandardCallback<import("./types").StandardError, any> | {
            create?: boolean | undefined;
            windowIdentifiers?: import("./services/window/types").WindowIdentifier[] | undefined;
        } | undefined, cb?: import("./types").StandardCallback<import("./types").StandardError, any> | undefined) => void;
        cancelTilingOrTabbing: (params: {
            windowIdentifier?: import("./services/window/types").WindowIdentifier | undefined;
        }, cb?: (() => void) | undefined) => void;
        startTilingOrTabbing: (params: {
            windowIdentifier: import("./services/window/types").WindowIdentifier;
        }, cb?: (() => void) | undefined) => void;
        stopTilingOrTabbing: (params: {
            mousePosition?: {
                x: number;
                y: number;
            } | undefined;
            action?: string | undefined;
            allowDropOnSelf?: boolean | undefined;
        }, cb?: (() => void) | undefined) => void;
        sendIdentifierForTilingOrTabbing: (params: {
            windowIdentifier: import("./services/window/types").WindowIdentifier;
        }, cb?: (() => void) | undefined) => void;
        stopMovingWindow: () => void;
        startMovingWindow: (event: MouseEvent) => void;
        setShape: (params?: ({
            x: Number;
            y: Number;
            width: Number;
            height: Number;
        } | null)[] | undefined, callback?: Function) => void;
        setActive: (active: boolean) => void;
        getWindowIdentifier: () => import("./services/window/types").WindowIdentifier;
        isMouseOverDOMElement: (element: Element, cb?: ((result: boolean) => void) | undefined) => Promise<boolean>;
        isPointInBox: (point: {
            x: number;
            y: number;
        }, box: {
            top: number;
            left: number;
            bottom?: number | undefined;
            right?: number | undefined;
            width: number;
            height: number;
        }) => boolean;
        getDesktopBoundingBox: (element: string | Element) => Promise<{
            top: number;
            left: number;
            width: number;
            height: number;
            right: number;
            bottom: number;
        }>;
        getCurrentWindow: () => import("./FEA").FEAWindow;
        getSpawnData: () => any;
        setWindowTitle: (title: string) => void;
        ejectFromGroup: () => void;
        headerCommandChannel: (commandChannel: (arg0: any, arg1: any) => void) => void;
        addListeners: () => void;
        formGroup: () => void;
        getWindowNameForDocking: () => any;
        removeComponentState: (params: {
            field?: string | undefined;
            fields?: {
                field: string;
            }[] | undefined;
            windowName?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setComponentState: <T_8 = any>(params: {
            field?: string | undefined;
            fields?: {
                field: string;
                value: T_8;
            }[] | undefined;
            value?: T_8 | undefined;
            windowName?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        getComponentState: <T_9 = any>(params: {
            field?: string | undefined;
            fields?: string[] | undefined;
            windowName?: string | undefined;
        }, cb?: import("./types").StandardErrorCallback<T_9> | undefined) => import("./types").StandardPromise<T_9>;
        injectDOM: (headerHeight: number) => void;
        setTaskbarIconOverlay: (url: string | null) => void;
        restore: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setAlwaysOnTop: (alwaysOnTop: boolean, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        bringWindowToFront: (cb?: import("./types").StandardErrorCallback<void> | undefined) => void;
        bringToFront: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        minimize: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        maximize: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        saveWindowBounds: (bounds: import("./services/window/types").WindowBounds, setActiveWorkspaceDirty: boolean) => void;
        getWindowBounds: () => import("./services/window/types").Bounds;
        cacheInitialBounds: () => Promise<void>;
        retrieveMonitorDimensions: (cb: (monitorInfo: import("./FEA").MonitorCoordinates) => void) => Promise<void>;
        getWindowTitle: () => string | null;
        close: (params: {
            removeFromWorkspace: boolean;
            closeWindow: boolean;
            ignoreParent?: boolean | undefined;
            userInitiated?: boolean | undefined;
        }, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setWindowTitlePrivate: (title: string) => void;
    };
    WorkspaceClient: {
        saveWorkspaceTemplateToConfigFile: (params: any) => void;
        addWorkspaceDefinition: (params: any, cb: any) => Promise<Record<string, string>>;
        getWorkspaceDefinition: (params: any, cb: any) => Promise<unknown>;
        createNewWorkspace: (workspaceName: any, params: any, cb: any) => Promise<{
            workspaceName: string;
        }>;
        setWorkspaces: (params: any, cb: any) => Promise<unknown>;
        initialize: () => void;
        onReady: (cb?: any) => void;
        removeWindow: (params: any, cb: any) => void;
        addWindow: (params: any, cb: any) => void;
        readonly workspaces: string[];
        readonly activeWorkspace: import("./services/workspace/types").Workspace | undefined;
        export: (params: {
            workspaceName: string;
        }, cb: Function) => Promise<unknown>;
        import: (params: {
            workspaceJSONDefinition: Record<string, string | import("./services/workspace/types").Workspace>;
            force: boolean;
        }, cb?: Function | undefined) => Promise<Record<string, string>>;
        exportToFile: (params: {
            workspaceTemplateDefinition: any;
        }) => void;
        createWorkspace: (workspaceName: string, params?: {
            switchAfterCreation?: boolean | undefined;
        } | undefined, cb?: (err: any, result: {
            workspaceName: string;
        }) => void) => Promise<{
            workspaceName: string;
        }>;
        isWorkspaceDirty: (cb?: Function | undefined) => Promise<boolean>;
        _getWindowState: (params: {
            windowName: string;
            stateVars: import("./services/workspace/windowStorageManager").StateType[];
        }) => Promise<import("./clients/routerClient").RouterResponse<Partial<import("./services/workspace/windowStorageManager").CompleteWindowState>>>;
        _setWindowState: (params: any) => Promise<import("./clients/routerClient").RouterResponse<boolean>>;
        switchTo: (params: {
            name: string;
        }, cb?: import("./types").StandardErrorCallback<{
            data: import("./services/workspace/types").Workspace;
        }> | undefined) => Promise<{
            data: import("./services/workspace/types").Workspace;
        }>;
        saveAs: (params: {
            name?: string | undefined;
            force?: boolean | undefined;
        }, cb?: Function | undefined) => Promise<unknown>;
        workspaceExists: (workspaceName: any) => void;
        save: (cb?: Function | undefined) => Promise<unknown>;
        rename: (params: {
            oldName: string;
            newName: string;
            removeOldWorkspace?: boolean | undefined;
            overwriteExisting?: boolean | undefined;
        }, cb?: Function | undefined) => Promise<unknown>;
        remove: (params: {
            workspace?: {
                name: string;
            } | undefined;
            name?: string | undefined;
        }, cb?: Function | undefined) => Promise<unknown>;
        setWorkspaceOrder: (params: any, cb?: Function | undefined) => Promise<unknown>;
        getWorkspaceNames: (cb?: import("./types").StandardErrorCallback<string[]> | undefined) => Promise<unknown>;
        getWorkspaceActions: (cb?: import("./types").StandardErrorCallback<Record<string, string>> | undefined) => Record<string, string>;
        getWorkspaces: (cb?: Function | undefined) => Promise<unknown>;
        getActiveWorkspace: (cb?: import("./types").StandardErrorCallback<{
            data: import("./services/workspace/types").Workspace;
        }> | undefined) => Promise<{
            data: import("./services/workspace/types").Workspace;
        }>;
        bringWindowsToFront: (params?: {
            monitor: string;
            windowIdentifier?: any;
        } | undefined, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        minimizeAll: (params?: {
            monitor: string;
            windowIdentifier?: any;
        } | undefined, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        autoArrange: (params: any, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        addEventListener: (event: import("./services/workspace/types").WorkspaceEventName, handler: import("./clients/workspaceClient").FinsembleEventHandler) => void;
        removeEventListener: (event: import("./services/workspace/types").WorkspaceEventName, handler: import("./clients/workspaceClient").FinsembleEventHandler) => void;
    };
    DialogManager: {
        userInputTimeout: number | null;
        readonly openerMessage: import("./clients/routerClient").ResponderMessage<any, any> | null;
        initialize: () => void;
        onReady: (cb?: any) => void;
        createStore: (cb?: (() => void) | undefined) => Promise<void>;
        getAvailableDialog: (type: string, cb?: ((dialog: import("./services/window/types").WindowIdentifier | null) => void) | undefined) => Promise<import("./services/window/types").WindowIdentifier | null>;
        sendQueryToDialog: (identifier: import("./services/window/types").WindowIdentifier, options: any, onUserInput: import("./types").StandardErrorCallback<any>) => Promise<void>;
        open: (type: string, options: any, onUserInput: import("./types").StandardErrorCallback<any>) => Promise<string | null>;
        spawnDialog: (params: import("./services/window/types").SpawnParams, inputParams: any, dialogResponseCallback: import("./types").StandardErrorCallback<any>, cb?: import("./types").StandardErrorCallback<import("./clients/launcherClient").SpawnResponse> | undefined) => import("./types").StandardPromise<import("./clients/launcherClient").SpawnResponse>;
        registerDialogCallback: (cb?: import("./types").StandardErrorCallback<import("./clients/routerClient").ResponderMessage<any, any>> | undefined) => Promise<void>;
        getParametersFromInDialog: () => any;
        respondAndExitFromInDialog: (responseParameters: any) => void;
        showDialog: () => Promise<void>;
        registerModal: () => Promise<string | null>;
        showModal: (cb?: ((error?: string | undefined) => void) | undefined) => Promise<string | null>;
        hideModal: () => Promise<string | null>;
        respondToOpener: (data?: any) => Promise<void>;
    };
    AuthenticationClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        beginAuthentication: (params: {
            profile?: string | undefined;
            spawnParams?: import("./services/window/types").SpawnParams | undefined;
        }, cb?: import("./types").StandardErrorCallback<any> | undefined) => import("./types").StandardPromise<any>;
        completeOAUTH: (err?: string | undefined, params?: any, cb?: import("./types").StandardErrorCallback<any> | undefined) => import("./types").StandardPromise<any>;
        transmitSignOnToAuthService: (signOnData: {
            username?: string | undefined;
            password?: string | undefined;
            signOnKey: string;
            error?: string | undefined;
        }) => void;
        getCurrentCredentials: (cb?: import("./types").StandardErrorCallback<any> | undefined) => import("./types").StandardPromise<any>;
        publishAuthorization: (user: string, credentials: any) => void;
        appRejectAndRetrySignOn: (signOnKey: string, params: {
            userMsg?: string | undefined;
        }, cb: import("./types").StandardCallback<import("./types").StandardError, any>) => void;
        appRejectSignOn: (signOnKey: any) => void;
        appAcceptSignOn: (signOnKey: any) => void;
        appSignOn: (signOnKey: any, params: {
            icon: string;
            prompt: string;
            force: boolean;
            userMsg?: string | undefined;
        }, cb?: import("./types").StandardCallback<import("./types").StandardError, any> | undefined) => Promise<{
            err?: import("./types").StandardError;
            data?: any;
        }>;
    };
    ConfigClient: {
        initialize(): void;
        onReady: (cb?: any) => void;
        triggerListeners(listenerKey: string, data: any): void;
        handleChanges(err: import("./types").StandardError, response: {
            data: {
                store: string;
                storeData: any;
                field: string | null;
                value: any;
            };
        }): void;
        changeSub(change: string): Promise<void>;
        addListener: <T_10 = any>(params: {
            field: string | null;
        }, fn: import("./clients/StoreModel").ListenerFunction<T_10>, cb?: (() => void) | undefined) => Promise<void>;
        addListeners: <T_11 = any>(params: string[] | import("./clients/configClient").ListenerParam[], fn: import("./clients/StoreModel").ListenerFunction<T_11>, cb?: (() => void) | undefined) => Promise<void> | undefined;
        getManifest: (cb?: import("./types").StandardErrorCallback<import("./types").Manifest> | undefined) => import("./types").StandardPromise<import("./types").Manifest>;
        getPreferences: (cb?: import("./types").StandardErrorCallback<Record<string, any> | null> | undefined) => import("./types").StandardPromise<Record<string, any> | null>;
        getValue: <T_12 = any>(params: string | import("./clients/configClient").FieldOnlyParam, cb?: import("./types").StandardErrorCallback<T_12> | undefined) => import("./types").StandardPromise<T_12>;
        getValues: <T_13 = any>(fields?: string[] | import("./clients/configClient").FieldOnlyParam[] | null | undefined, cb?: import("./types").StandardErrorCallback<Record<string, T_13>> | undefined) => import("./types").StandardPromise<Record<string, T_13>>;
        processAndSet: (params: {
            newConfig: Record<string, any>;
            overwrite: boolean;
            replace: boolean;
        }, cb?: import("./types").StandardErrorCallback<import("./clients/routerClient").QueryResponse<import("./types").Manifest>> | undefined) => import("./types").StandardPromise<import("./types").Manifest>;
        removeListener: (params: {
            field: string | null;
        }, fn: import("./clients/StoreModel").ListenerFunction<any>, cb?: Function | undefined) => void;
        removeListeners: (params: import("./clients/configClient").RemoveListenersType, fn?: import("./clients/StoreModel").ListenerFunction<any> | undefined, cb?: import("./types").StandardErrorCallback<boolean> | undefined) => void;
        removeValue: (field: String, cb?: import("./types").StandardErrorCallback<void> | undefined) => Promise<{
            err: string | null | undefined;
        }>;
        removeValues: (params: import("./clients/configClient").FieldAndValueParams, cb?: import("./types").StandardErrorCallback<void> | undefined) => Promise<{
            err: import("./types").StandardError;
        }>;
        setPreference: (params: import("./clients/configClient").FieldAndValueParam, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        setValue: (params: import("./clients/configClient").FieldAndValueParam, cb?: import("./types").StandardErrorCallback<void> | undefined) => Promise<{
            err: string | null | undefined;
        }>;
        setValues: (fields: import("./clients/configClient").FieldAndValueParams, cb?: import("./types").StandardErrorCallback<void> | undefined) => Promise<{
            err: string | null | undefined;
        }>;
        unsetPreference: (params: import("./clients/configClient").FieldOnlyParam, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
    };
    DragAndDropClient: import("./deprecated/dragAndDropClient").DragAndDropClient;
    Logger: {
        error: (...args: any[]) => void;
        warn: (...args: any[]) => void;
        info: (...args: any[]) => void;
        log: (...args: any[]) => void;
        debug: (...args: any[]) => void;
        verbose: (...args: any[]) => void;
        deprecated: (...args: any[]) => void;
        start: (routerClient?: {
            onReady: (cb?: (() => void) | undefined) => Promise<void>;
            addListener: <T = any>(channel: string, eventHandler: import("./clients/routerClient").ListenerCallback<T>) => import("./clients/routerClient").RouterListenerUnsubscribe;
            transmit: <T_1 = any>(toChannel: string, data: T_1, options?: {
                suppressWarnings: boolean;
            } | undefined) => void;
            removeListener: (channel: string, eventHandler: Function) => void;
            addResponder: <Q = any, R = any>(channel: string, queryEventHandler: import("./types").StandardErrorCallback<import("./clients/routerClient").ResponderMessage<Q, R>>) => void;
            query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
                timeout?: number | undefined;
                logWhenNoResponder?: boolean | undefined;
            } | import("./clients/routerClient").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./clients/routerClient").QueryResponseCallback<R_1> | undefined) => Promise<import("./clients/routerClient").StandardQueryResponse<R_1>>;
            removeResponder: (responderChannel: string) => void;
            addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
                subscribeCallback?: import("./clients/routerClient").SubscribeCallback<T_2> | undefined;
                unsubscribeCallback?: import("./clients/routerClient").UnsubscribeCallback | undefined;
                publishCallback?: import("./clients/routerClient").PublishCallback<T_2> | undefined;
            } | undefined, callback?: ((err?: string | Error | undefined, result?: "success" | undefined) => void) | undefined) => void;
            removePubSubResponder: (topic: string | RegExp) => void;
            subscribe: <T_3 = any>(topic: string, notifyCallback: (err: import("./types").StandardError, response: import("./clients/routerClient").SubscriberResponse<T_3>) => void) => {
                subscribeID: string;
                topic: string;
            };
            publish: <T_4 = any>(topic: string, event: T_4) => void;
            unsubscribe: (subscribeIDStruct: {
                subscribeID: string;
                topic: string;
            }) => void;
            trustedMessage: (incomingMessage: import("./clients/routerClient").RouterMessage<any>) => boolean;
            disconnectAll: () => void;
            calibrateTimeWithRouterService(callback: (offset: number) => void): void;
        } | undefined) => void;
        channelFilter: (channel: string) => boolean;
        setting: () => import("./services/logger/types").CentralLoggerClientState;
        callStack: () => string;
        unregisterClient: (params?: {
            clientName: string;
            deleteFromPersistence?: boolean | undefined;
            viewId?: number | undefined;
        } | undefined, cb?: ((err: import("./types").StandardError, data?: any) => void) | undefined) => void;
        setRouterClient: (routerClient: {
            onReady: (cb?: (() => void) | undefined) => Promise<void>;
            addListener: <T = any>(channel: string, eventHandler: import("./clients/routerClient").ListenerCallback<T>) => import("./clients/routerClient").RouterListenerUnsubscribe;
            transmit: <T_1 = any>(toChannel: string, data: T_1, options?: {
                suppressWarnings: boolean;
            } | undefined) => void;
            removeListener: (channel: string, eventHandler: Function) => void;
            addResponder: <Q = any, R = any>(channel: string, queryEventHandler: import("./types").StandardErrorCallback<import("./clients/routerClient").ResponderMessage<Q, R>>) => void;
            query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
                timeout?: number | undefined;
                logWhenNoResponder?: boolean | undefined;
            } | import("./clients/routerClient").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./clients/routerClient").QueryResponseCallback<R_1> | undefined) => Promise<import("./clients/routerClient").StandardQueryResponse<R_1>>;
            removeResponder: (responderChannel: string) => void;
            addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
                subscribeCallback?: import("./clients/routerClient").SubscribeCallback<T_2> | undefined;
                unsubscribeCallback?: import("./clients/routerClient").UnsubscribeCallback | undefined;
                publishCallback?: import("./clients/routerClient").PublishCallback<T_2> | undefined;
            } | undefined, callback?: ((err?: string | Error | undefined, result?: "success" | undefined) => void) | undefined) => void;
            removePubSubResponder: (topic: string | RegExp) => void;
            subscribe: <T_3 = any>(topic: string, notifyCallback: (err: import("./types").StandardError, response: import("./clients/routerClient").SubscriberResponse<T_3>) => void) => {
                subscribeID: string;
                topic: string;
            };
            publish: <T_4 = any>(topic: string, event: T_4) => void;
            unsubscribe: (subscribeIDStruct: {
                subscribeID: string;
                topic: string;
            }) => void;
            trustedMessage: (incomingMessage: import("./clients/routerClient").RouterMessage<any>) => boolean;
            disconnectAll: () => void;
            calibrateTimeWithRouterService(callback: (offset: number) => void): void;
        }) => void;
        onStateChanged(cb: (newState: import("./services/logger/types").CentralLoggerClientState) => void): void;
        system: {
            error: (...args: any[]) => void;
            warn: (...args: any[]) => void;
            info: (...args: any[]) => void;
            log: (...args: any[]) => void;
            debug: (...args: any[]) => void;
            verbose: (...args: any[]) => void;
            deprecated: (...args: any[]) => void;
        };
        perf: {
            error: (...args: any[]) => void;
            warn: (...args: any[]) => void;
            info: (...args: any[]) => void;
            log: (...args: any[]) => void;
            debug: (...args: any[]) => void;
            verbose: (...args: any[]) => void;
            deprecated: (...args: any[]) => void;
        };
        console: {
            error: (...args: any[]) => void;
            warn: (...args: any[]) => void;
            info: (...args: any[]) => void;
            log: (...args: any[]) => void;
            debug: (...args: any[]) => void;
            verbose: (...args: any[]) => void;
            deprecated: (...args: any[]) => void;
        };
    };
    /** @deprecated */
    baseClient: typeof _BaseClient;
    SearchClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        invokeProviderAction: (provider: {
            channel: string;
        }) => void;
        invokeItemAction: (item: any, action: {
            name: string;
        }) => void;
        search: (params: {
            text: string;
            windowName?: string | undefined;
        }, cb: Function) => Promise<void>;
        unregister: (params: {
            name: string;
        }, cb?: Function | undefined) => Promise<void>;
        register: (params: {
            name: string;
            searchCallback: Function;
            itemActionCallback?: Function | undefined;
            providerActionCallback?: Function | undefined;
            providerActionTitle?: string | null | undefined;
        }, cb?: import("./types").StandardErrorCallback<{
            status: string;
        }> | undefined) => import("./types").StandardPromise<{
            status: string;
        }>;
    };
    HotkeyClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        onClose: (cb?: (() => void) | undefined) => void;
        addGlobalHotkey: (keyArr: string[], handler: any, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        removeAllHotkeys: (cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        removeGlobalHotkey: (keyArr: string[], handler: any, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        addLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        removeLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./types").StandardErrorCallback<void> | undefined) => import("./types").StandardPromise<void>;
        addBrowserHotkey: (keyArr: string[], handler: () => void, addedByUser?: boolean | undefined) => void;
    };
    NotificationClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        fetchHistory: (options?: string | import("./services/notification/types").INotificationHistoryOptions | undefined, filter?: import("./services/notification/types").IFilter | undefined) => Promise<import("./services/notification/types").INotification[]>;
        getLastIssuedAt: (source?: string | undefined) => Promise<string>;
        performAction: (notifications: Partial<import("./services/notification/types").INotification>[], action: import("./services/notification/types").IAction) => Promise<void>;
        markRead: (notifications: import("./services/notification/types").INotification[]) => Promise<void>;
        markUnread: (notifications: import("./services/notification/types").INotification[]) => Promise<void>;
        deleteNotifications: (notifications: import("./services/notification/types").INotification[]) => Promise<void>;
        notify: (notifications: Partial<import("./services/notification/types").INotification> | Partial<import("./services/notification/types").INotification>[]) => Promise<void>;
        subscribe: (subscription: Partial<import("./services/notification/types").ISubscription>, onNotification: import("./services/notification/types").OnNotificationCallback) => Promise<string>;
        unsubscribe: (subscriptionId: string) => Promise<void>;
        unsubscribeAll: () => void;
        mute: (filter: import("./services/notification/types").IMuteFilter | import("./services/notification/types").IMuteFilter[]) => Promise<void>;
        unmute: (filter: import("./services/notification/types").IMuteFilter | import("./services/notification/types").IMuteFilter[]) => Promise<void>;
        getPreferences: () => Promise<Object>;
        getMuteFilters: () => Promise<import("./services/notification/types").IMuteFilter[]>;
        getSources: () => Promise<string[]>;
        onClose: (cb?: (() => void) | undefined) => void;
        Notification: typeof import("./clients/notificationClient").Notification;
        ActionTypes: typeof import("./clients/notificationClient").ActionTypes;
        Subscription: typeof import("./clients/notificationClient").Subscription;
        Action: typeof import("./clients/notificationClient").Action;
        Filter: typeof import("./clients/notificationClient").Filter;
        actionTypes: typeof import("./clients/notificationClient").ActionTypes;
    };
};
//# sourceMappingURL=main.d.ts.map