/**
 * These are to support legacy exports (see notes below).
 */
import { BaseService as baseService } from "./platform/services/baseService";
import { _BaseClient } from "./deprecated/baseClient";
import UserNotification from "./common/toast";
import * as Util from "./common/util";
import DependencyManager from "./common/dependencyManager";
import baseStorage from "./platform/services/storage/adapters/base";
import { System } from "./common/system";
import { FinsembleWindow } from "./common/FinsembleWindow";
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";
export * from "./ui";
export * from "./platform/preloads/BloombergBridgeClient";
/**
 * 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 "./platform/services/window/types";
export { WindowBounds } from "./platform/services/window/types";
export { WorkspaceEventName } from "./platform/services/workspace/types";
export { WindowEventName, WrapState } from "./platform/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("./platform/services/storage/adapters/types").IBaseStorage, args: string) => void;
};
export { baseStorage };
export { IBaseStorage, StorageKeyTopic } from "./platform/services/storage/adapters/types";
/**
 * @ignore Don't display these in Typedoc output
 * This section is for backward compatibility
 */
export { FinsembleWindow, baseService, UserNotification, DependencyManager, System, Util };
/**
 * @ignore Don't display these in Typedoc output
 * This section is for backward compatibility
 */
export declare const Clients: {
    RouterClient: {
        onReady: (cb?: () => void) => Promise<void>;
        onFailure: (cb?: () => void) => Promise<void>;
        addListener: <T = any>(channel: string, eventHandler: import("./types").ListenerCallback<T>) => import("./types").RouterListenerUnsubscribe;
        transmit: <T = any>(toChannel: string, data: T, options?: {
            suppressWarnings: boolean;
        }) => void;
        removeListener: (channel: string, eventHandler: Function) => void;
        addResponder: <Q = any, R = any>(channel: string, queryEventHandler: import("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage<Q, R>>) => void;
        query: <Q = any, R = any>(responderChannel: string, queryEvent: Q, queryParams?: {
            timeout?: number;
            logWhenNoResponder?: boolean;
        } | import("./types").QueryResponseCallback<R>, responseEventHandler?: import("./types").QueryResponseCallback<R>) => Promise<import("./types").StandardQueryResponse<R>>;
        removeResponder: (responderChannel: string) => void;
        addPubSubResponder: <T = any>(topic: string | RegExp, initialState?: object, params?: {
            subscribeCallback?: import("./types").SubscribeCallback<T>;
            unsubscribeCallback?: import("./types").UnsubscribeCallback;
            publishCallback?: import("./types").PublishCallback<T>;
        }, callback?: (err?: string | Error, result?: "success") => void) => void;
        removePubSubResponder: (topic: string | RegExp) => void;
        subscribe: <T = any>(topic: string, notifyCallback: (err: import("./typedoc-types").StandardError, response: import("./types").SubscriberResponse<T>) => void) => {
            subscribeID: string;
            topic: string;
        };
        publish: <T = any>(topic: string, event: T) => void;
        unsubscribe: (subscribeIDStruct: {
            subscribeID: string;
            topic: string;
        }) => void;
        trustedMessage: (incomingMessage: import("./types").RouterMessage) => boolean;
        disconnectAll: () => void;
        calibrateTimeWithRouterService: (callback: (offset: number) => void) => void;
    };
    StorageClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        clearCache: (cb?: import("./typedoc-types").StandardErrorCallback<void>, params?: {
            topic: string;
        }) => import("./typedoc-types").StandardPromise<void>;
        remove: (params: {
            key: string;
            topic: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        getMultiple: (params: any, cb?: import("./typedoc-types").StandardErrorCallback<any>) => import("./typedoc-types").StandardPromise<any>;
        keys: (params: {
            topic: string;
            keyPrefix?: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<string[]>) => import("./typedoc-types").StandardPromise<string[]>;
        getStandardized: <T = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        get: <T = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<T>) => Promise<T>;
        save: (params: import("./types").ComponentMutateParams, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        setStore: (params: {
            topic: string;
            dataStore?: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        setUser: (params: {
            user: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        delete: (...args: any[]) => void;
        remove1: (params: {
            key: string;
            topic: string;
        }) => void;
        get1: <T = any>(params: {
            key: string;
            topic: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<T>) => Promise<T>;
        save1: (params: {
            key: string;
            topic: string;
            value: any;
        }) => void;
        keys1: (params: {
            topic: string;
            keyPrefix?: string;
        }) => Promise<string[]>;
    };
    AppsClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        addToGroups: (params: {
            windowIdentifier?: import("./types").WindowIdentifier;
            groupNames?: string[];
        }, cb: (err?: import("./typedoc-types").StandardError) => void) => Promise<{
            err: import("./typedoc-types").StandardError;
        }>;
        addUserDefinedComponent: (params: {
            name: string;
            url: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        addWindowsToGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        bringWindowsToFront: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        clone: (toClone?: import("./types").WindowIdentifier | null, spawnParams?: import("./types").SpawnParams | null, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => Promise<{
            error?: import("./typedoc-types").StandardError;
            response?: import("./clients/appsClient").SpawnResponse;
        }>;
        createWindowGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        getActiveAndPendingWindowNames: (cb?: Function) => Promise<{
            err: any;
            data: any;
        }>;
        getActiveDescriptors: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, import("./types").WindowDescriptor>>) => import("./typedoc-types").StandardPromise<Record<string, import("./types").WindowDescriptor>>;
        getComponentDefaultConfig: (componentType: string, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentDescriptor>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentDescriptor>;
        getComponentList: (cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentList>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentList>;
        getComponentsThatCanReceiveDataTypes: (params: {
            dataTypes: string[];
        }, cb?: Function) => Promise<unknown>;
        getGroupsForWindow: (params: {
            windowIdentifier: import("./types").WindowIdentifier;
        } | null, cb?: Function) => Promise<unknown>;
        getMonitor: (windowIdentifier: import("./types").WindowIdentifier, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").MonitorInfo>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").MonitorInfo>;
        getMonitorInfo: (params?: {
            monitor?: import("./common/Monitors").MonitorCommand;
            windowIdentifier?: import("./types").WindowIdentifier;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail>) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
        getMonitorInfoAll: (cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail[]>) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail[]>;
        getMyWindowIdentifier: (cb?: (windowIdentifier: import("./types").WindowIdentifier) => void) => Promise<import("./types").WindowIdentifier>;
        getPendingWindows: () => import("./typedoc-types").StandardPromise<string[]>;
        hyperFocus: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
            componentType?: string;
        }, cb?: () => void) => Promise<void>;
        minimizeWindows: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        registerComponent: (params: {
            componentType: string;
            manifest: import("./clients/appsClient").ComponentDescriptor;
        }, cb: import("./typedoc-types").StandardErrorCallback<string>) => import("./typedoc-types").StandardPromise<string>;
        removeUserDefinedComponent: (params: {
            name: string;
            url?: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        removeWindowsFromGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        showWindow: (windowLocator: import("./types").WindowLocator, params: import("./types").ShowWindowParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnResponse>;
        spawn: (component: string, params: import("./types").SpawnParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => Promise<{
            error?: import("./typedoc-types").StandardError;
            response?: import("./clients/appsClient").SpawnResponse;
        }>;
        spawnTabCollection: ({ componentList, globalParams, }: {
            componentList: {
                appID: string;
                individualParams?: import("./types").SpawnParams;
            }[];
            globalParams?: import("./types").TabbedGlobalSpawnParams;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnTabCollectionResponse>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnTabCollectionResponse>;
        toggleWindowOnClick: (element: HTMLElement, windowLocator: import("./types").WindowLocator, params: import("./types").ShowWindowParams) => void;
        unRegisterComponent: (params: {
            componentType: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<string>) => import("./typedoc-types").StandardPromise<string>;
        addApps: (apps: import("./types").FDC3AppDefinition[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
        removeApps: (appIds: string[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<string[]>;
        getApps: (appIds?: string[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
    };
    LauncherClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        addToGroups: (params: {
            windowIdentifier?: import("./types").WindowIdentifier;
            groupNames?: string[];
        }, cb: (err?: import("./typedoc-types").StandardError) => void) => Promise<{
            err: import("./typedoc-types").StandardError;
        }>;
        getGroupsForWindow: (params: {
            windowIdentifier: import("./types").WindowIdentifier;
        } | null, cb?: Function) => Promise<unknown>;
        removeWindowsFromGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        addWindowsToGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        createWindowGroup: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
        }, cb?: Function) => Promise<unknown>;
        minimizeWindows: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        hyperFocus: (params: {
            windowList?: string[] | import("./types").WindowIdentifier[];
            groupName?: string;
            componentType?: string;
        }, cb?: () => void) => Promise<void>;
        bringWindowsToFront: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        getComponentsThatCanReceiveDataTypes: (params: {
            dataTypes: string[];
        }, cb?: Function) => Promise<unknown>;
        removeUserDefinedComponent: (params: {
            name: string;
            url?: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        addUserDefinedComponent: (params: {
            name: string;
            url: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        getPendingWindows: () => import("./typedoc-types").StandardPromise<string[]>;
        getActiveAndPendingWindowNames: (cb?: Function) => Promise<{
            err: any;
            data: any;
        }>;
        getActiveDescriptors: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, import("./types").WindowDescriptor>>) => import("./typedoc-types").StandardPromise<Record<string, import("./types").WindowDescriptor>>;
        getMyWindowIdentifier: (cb?: (windowIdentifier: import("./types").WindowIdentifier) => void) => Promise<import("./types").WindowIdentifier>;
        getMonitor: (windowIdentifier: import("./types").WindowIdentifier, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").MonitorInfo>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").MonitorInfo>;
        spawn: (component: string, params: import("./types").SpawnParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => Promise<{
            error?: import("./typedoc-types").StandardError;
            response?: import("./clients/appsClient").SpawnResponse;
        }>;
        clone: (toClone?: import("./types").WindowIdentifier | null, spawnParams?: import("./types").SpawnParams | null, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => Promise<{
            error?: import("./typedoc-types").StandardError;
            response?: import("./clients/appsClient").SpawnResponse;
        }>;
        toggleWindowOnClick: (element: HTMLElement, windowLocator: import("./types").WindowLocator, params: import("./types").ShowWindowParams) => void;
        showWindow: (windowLocator: import("./types").WindowLocator, params: import("./types").ShowWindowParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnResponse>;
        unRegisterComponent: (params: {
            componentType: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<string>) => import("./typedoc-types").StandardPromise<string>;
        registerComponent: (params: {
            componentType: string;
            manifest: import("./clients/appsClient").ComponentDescriptor;
        }, cb: import("./typedoc-types").StandardErrorCallback<string>) => import("./typedoc-types").StandardPromise<string>;
        getMonitorInfo: (params?: {
            monitor?: import("./common/Monitors").MonitorCommand;
            windowIdentifier?: import("./types").WindowIdentifier;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail>) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
        getMonitorInfoAll: (cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail[]>) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail[]>;
        getComponentDefaultConfig: (componentType: string, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentDescriptor>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentDescriptor>;
        getComponentList: (cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentList>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentList>;
        addApps: (apps: import("./types").FDC3AppDefinition[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
        removeApps: (appIds: string[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<string[]>;
        getApps: (appIds?: string[], cb?: import("./typedoc-types").StandardErrorCallback) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
        spawnTabCollection: ({ componentList, globalParams, }: {
            componentList: {
                appID: string;
                individualParams?: import("./types").SpawnParams;
            }[];
            globalParams?: import("./types").TabbedGlobalSpawnParams;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnTabCollectionResponse>) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnTabCollectionResponse>;
    };
    DistributedStoreClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        createStore: (params: {
            store: string;
            global?: boolean;
            persist?: boolean;
            values?: any;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel>) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
        getStore: (params: {
            store: string;
            global?: boolean;
            waitForPersistentStoreToLoad?: boolean;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel>) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
        createGlobalStore: (params: {
            store: string;
            persist?: boolean;
            values?: any;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel>) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
        removeStore: (params: {
            store: string;
            global?: boolean;
        }, cb?: import("./typedoc-types").StandardErrorCallback<boolean>) => import("./typedoc-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;
        }[];
        fitToDOM: typeof import("./clients/windowClient").fitToDOM;
        getBounds: typeof import("./clients/windowClient").getBounds;
        getWindowGroups: () => {
            windowNames: string[];
            isMovable: boolean;
            isAlwaysOnTop: boolean;
            topRightWindow: string;
            isARectangle: boolean;
        }[];
        initialize: Function;
        onReady: Function;
        showAtMousePosition: typeof import("./clients/windowClient").showAtMousePosition;
        getMonitorInfo: (params?: {
            monitor?: import("./common/Monitors").MonitorCommand;
            windowIdentifier?: import("./types").WindowIdentifier;
        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail>) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
        cancelTilingOrTabbing: typeof import("./clients/windowClient").cancelTilingOrTabbing;
        startTilingOrTabbing: typeof import("./clients/windowClient").startTilingOrTabbing;
        stopTilingOrTabbing: typeof import("./clients/windowClient").stopTilingOrTabbing;
        stopMovingWindow: typeof import("./clients/windowClient").stopMovingWindow;
        startMovingWindow: typeof import("./clients/windowClient").startMovingWindow;
        setShape: typeof import("./clients/windowClient").setShape;
        setActive: (active: boolean) => void;
        getWindowIdentifier: typeof import("./clients/windowClient").getWindowIdentifier;
        isMouseOverDOMElement: (element: Element, cb?: (result: boolean) => void) => Promise<boolean>;
        isPointInBox: (point: {
            x: number;
            y: number;
        }, box: {
            top: number;
            left: number;
            bottom?: number;
            right?: number;
            width: number;
            height: number;
        }) => boolean;
        getDesktopBoundingBox: (element: string | Element) => Promise<{
            top: number;
            left: number;
            width: number;
            height: number;
            right: number;
            bottom: number;
        }>;
        getCurrentWindow: typeof import("./clients/windowClient").getCurrentWindow;
        getSpawnData: typeof import("./clients/windowClient").getSpawnData;
        setWindowTitle: (title: string) => void;
        ejectFromGroup: typeof import("./clients/windowClient").ejectFromGroup;
        addListeners: () => void;
        formGroup: typeof import("./clients/windowClient").formGroup;
        getTabCollection: typeof import("./clients/windowClient").getTabCollection;
        getWindowNameForDocking: typeof import("./clients/windowClient").getWindowNameForDocking;
        removeComponentState: typeof import("./clients/windowClient").removeComponentState;
        setComponentState: typeof import("./clients/windowClient").setComponentState;
        getComponentState: typeof import("./clients/windowClient").getComponentState;
        injectDOM: (headerHeight: number) => void;
        setTaskbarIconOverlay: typeof import("./clients/windowClient").setTaskbarIconOverlay;
        restore: typeof import("./clients/windowClient").restore;
        setAlwaysOnTop: typeof import("./clients/windowClient").setAlwaysOnTop;
        bringWindowToFront: typeof import("./clients/windowClient").bringWindowToFront;
        bringToFront: typeof import("./clients/windowClient").bringToFront;
        minimize: typeof import("./clients/windowClient").minimize;
        maximize: typeof import("./clients/windowClient").maximize;
        saveWindowBounds: (bounds: import("./types").WindowBounds, setActiveWorkspaceDirty: boolean) => void;
        getWindowBounds: () => import("./types").Bounds;
        cacheInitialBounds: () => Promise<void>;
        retrieveMonitorDimensions: (cb: (monitorInfo: import("./FEA").MonitorCoordinates) => void) => Promise<void>;
        getWindowTitle: typeof import("./clients/windowClient").getWindowTitle;
        close: typeof import("./clients/windowClient").close;
        addToTabCollection: typeof import("./clients/windowClient").addToTabCollection;
        createTabCollection: typeof import("./clients/windowClient").createTabCollection;
        removeFromTabCollection: typeof import("./clients/windowClient").removeFromTabCollection;
        promoteTab: typeof import("./clients/windowClient").promoteTab;
        getPromotedTab: typeof import("./clients/windowClient").getPromotedTab;
        getTabCollectionForWindow: typeof import("./clients/windowClient").getTabCollectionForWindow;
    };
    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("./types").Workspace | undefined;
        export: (params: {
            workspaceName: string;
        }, cb: Function) => Promise<unknown>;
        import: (params: {
            workspaceJSONDefinition: Record<string, import("./types").Workspace | string>;
            force: boolean;
        }, cb?: Function) => Promise<Record<string, string>>;
        exportToFile: (params: {
            workspaceTemplateDefinition: any;
        }) => void;
        createWorkspace: (workspaceName: string, params?: {
            switchAfterCreation?: boolean;
        }, cb?: (err: any, result: {
            workspaceName: string;
        }) => void) => Promise<{
            workspaceName: string;
        }>;
        isWorkspaceDirty: (cb?: Function) => Promise<boolean>;
        _getWindowState: (params: {
            windowName: string;
            stateVars: import("./types").StateType[];
        }) => Promise<import("./types").RouterResponse<Partial<import("./types").CompleteWindowState>>>;
        _setWindowState: (params: any) => Promise<import("./types").RouterResponse<boolean>>;
        switchTo: (params: {
            name: string;
        }, cb?: import("./typedoc-types").StandardErrorCallback<{
            data: import("./types").Workspace;
        }>) => Promise<{
            data: import("./types").Workspace;
        }>;
        saveAs: (params: {
            name: string;
            force?: boolean;
        }, cb?: Function) => Promise<unknown>;
        workspaceExists: (workspaceName: any) => void;
        save: (cb?: Function) => Promise<unknown>;
        rename: (params: {
            oldName: string;
            newName: string;
            removeOldWorkspace?: boolean;
            overwriteExisting?: boolean;
        }, cb?: Function) => Promise<unknown>;
        remove: (params: {
            workspace?: {
                name: string;
            };
            name?: string;
        }, cb?: Function) => Promise<unknown>;
        setWorkspaceOrder: (params: any, cb?: Function) => Promise<unknown>;
        getWorkspaceNames: (cb?: import("./typedoc-types").StandardErrorCallback<string[]>) => Promise<string[]>;
        getWorkspaceActions: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, string>>) => Record<string, string>;
        getWorkspaces: (cb?: Function) => Promise<unknown>;
        getActiveWorkspace: (cb?: import("./typedoc-types").StandardErrorCallback<{
            data: import("./types").Workspace;
        }>) => Promise<{
            data: import("./types").Workspace;
        }>;
        bringWindowsToFront: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        minimizeAll: (params?: {
            windowList?: string[];
        }, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        autoArrange: (params: any, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        addEventListener: (event: import("./types").WorkspaceEventName, handler: import("./clients/workspaceClient").FinsembleEventHandler) => void;
        removeEventListener: (event: import("./types").WorkspaceEventName, handler: import("./clients/workspaceClient").FinsembleEventHandler) => void;
    };
    DialogManager: {
        userInputTimeout: number | null;
        readonly openerMessage: import("./types").ResponderMessage | null;
        initialize: () => void;
        onReady: (cb?: any) => void;
        createStore: (cb?: () => void) => Promise<void>;
        getAvailableDialog: (type: string, cb?: (dialog: import("./types").WindowIdentifier | null) => void) => Promise<import("./types").WindowIdentifier | null>;
        sendQueryToDialog: (identifier: import("./types").WindowIdentifier, options: any, onUserInput: import("./typedoc-types").StandardErrorCallback<any>) => Promise<void>;
        open: (type: string, options: any, onUserInput: import("./typedoc-types").StandardErrorCallback<any>) => Promise<string | null>;
        spawnDialog: (params: import("./types").SpawnParams, inputParams: any, dialogResponseCallback: import("./typedoc-types").StandardErrorCallback<any>, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/launcherClient").SpawnResponse>) => import("./typedoc-types").StandardPromise<import("./clients/launcherClient").SpawnResponse>;
        registerDialogCallback: (cb?: import("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage>) => Promise<void>;
        getParametersFromInDialog: () => Promise<any>;
        respondAndExitFromInDialog: (responseParameters: any) => Promise<void>;
        showDialog: () => Promise<void>;
        registerModal: () => Promise<string | null>;
        showModal: (cb?: (error?: string) => void) => Promise<string | null>;
        hideModal: () => Promise<string | null>;
        respondToOpener: (data?: any) => Promise<void>;
    };
    AuthenticationClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        beginAuthentication: (params: {
            profile?: string;
            spawnParams?: import("./types").SpawnParams;
        }, cb?: import("./typedoc-types").StandardErrorCallback<any>) => import("./typedoc-types").StandardPromise<any>;
        completeOAUTH: (err?: string | null, params?: any, cb?: import("./typedoc-types").StandardErrorCallback<any>) => import("./typedoc-types").StandardPromise<any>;
        transmitSignOnToAuthService: (signOnData: import("./clients/authenticationClient").SignOnData) => void;
        getCurrentCredentials: (cb?: import("./typedoc-types").StandardErrorCallback<any>) => import("./typedoc-types").StandardPromise<any>;
        publishAuthorization: (user: string, credentials: any) => void;
        appRejectAndRetrySignOn: (signOnKey: string, params: {
            userMsg?: string;
        }, cb: import("./typedoc-types").StandardCallback) => void;
        appRejectSignOn: (signOnKey: any) => void;
        appAcceptSignOn: (signOnKey: any) => void;
        appSignOn: (signOnKey: string, params: {
            icon: string;
            prompt: string;
            force: boolean;
            userMsg?: string;
        }, cb?: import("./typedoc-types").StandardCallback) => Promise<{
            err?: import("./typedoc-types").StandardError;
            data?: any;
        }>;
    };
    ConfigClient: {
        initialize(): void;
        onReady: (cb?: any) => void;
        triggerListeners(listenerKey: string, data: any): void;
        handleChanges(err: import("./typedoc-types").StandardError, response: {
            data: {
                store: string;
                storeData: any;
                field: string | null;
                value: any;
            };
        }): void;
        changeSub(change: string): Promise<void>;
        addListener: <T = any>(params: {
            field: string | null;
        } | import("./types").PathArray, fn: import("./types").ListenerFunction<T>, cb?: () => void) => Promise<void>;
        addListeners: <T = any>(params: import("./types").ListenerParam[] | string[] | import("./types").PathArrayListenerParam[], fn: import("./types").ListenerFunction<T>, cb?: () => void) => Promise<void> | undefined;
        getManifest: (cb?: import("./typedoc-types").StandardErrorCallback<import("./typedoc-types").Manifest>) => import("./typedoc-types").StandardPromise<import("./typedoc-types").Manifest>;
        getPreferences: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, any> | null>) => import("./typedoc-types").StandardPromise<Record<string, any> | null>;
        getValue: <T = any>(params: import("./types").FieldOnlyParam | string, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        getValues: <T = any>(fields?: import("./types").FieldOnlyParam[] | string[] | null, cb?: import("./typedoc-types").StandardErrorCallback<Record<string, T>>) => import("./typedoc-types").StandardPromise<Record<string, T>>;
        processAndSet: (params: {
            newConfig: Record<string, any>;
            overwrite: boolean;
            replace: boolean;
        }, cb?: import("./clients/configClient").ProcessAndSetCallback) => import("./typedoc-types").StandardPromise<import("./typedoc-types").Manifest>;
        removeListener: (params: {
            field: string | null;
        } | import("./types").PathArray, fn: import("./types").ListenerFunction<any>, cb?: Function) => void;
        removeListeners: (params: import("./types").RemoveListenersType, fn?: import("./types").ListenerFunction<any>, cb?: import("./typedoc-types").StandardErrorCallback<boolean>) => void;
        removeValue: <T = any>(params: import("./types").FieldOnlyParam | string, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        removeValues: (fields: import("./types").FieldOnlyParam[] | string[], cb?: import("./typedoc-types").StandardErrorCallback<void>) => Promise<{
            err: string | null | undefined;
        }>;
        setPreference: (params: import("./types").FieldAndValueParam, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        setValue: (params: import("./types").FieldAndValueParam, cb?: import("./typedoc-types").StandardErrorCallback<void>) => Promise<{
            err: string | null | undefined;
        }>;
        setValues: (fields: import("./types").FieldAndValueParams, cb?: import("./typedoc-types").StandardErrorCallback<void>) => Promise<{
            err: string | null | undefined;
        }>;
        unsetPreference: (params: import("./types").FieldOnlyParam, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        get: <T = any>(path: import("./types").PathArray | null, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        getMultiple: <T = any>(paths: import("./types").PathArray[], cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        set: <T = any>(path: import("./types").PathArray, value: any, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        setMultiple: <T = any>(pathsAndValues: import("./types").FieldPathArrayAndValue[], cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        remove: <T = any>(path: import("./types").PathArray, cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
        removeMultiple: <T = any>(paths: import("./types").PathArray[], cb?: import("./typedoc-types").StandardErrorCallback<T>) => import("./typedoc-types").StandardPromise<T>;
    };
    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?: import("./clients/routerClient").IRouterClient) => void;
        channelFilter: (channel: string) => boolean;
        setting: () => import("./types").CentralLoggerClientState;
        callStack: () => string;
        unregisterClient: (params?: {
            clientName: string;
            deleteFromPersistence?: boolean;
            viewId?: number;
        }, cb?: (err: import("./typedoc-types").StandardError, data?: any) => void) => void;
        setRouterClient: (routerClient: import("./clients/routerClient").IRouterClient) => void;
        onStateChanged(cb: (newState: import("./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;
        }, cb: Function) => Promise<void>;
        unregister: (params: {
            name: string;
        }, cb?: Function) => Promise<void>;
        register: (params: {
            name: string;
            searchCallback: Function;
            itemActionCallback?: Function;
            providerActionCallback?: Function;
            providerActionTitle?: string | null;
        }, cb?: import("./typedoc-types").StandardErrorCallback<{
            status: string;
        }>) => import("./typedoc-types").StandardPromise<{
            status: string;
        }>;
    };
    HotkeyClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        onClose: (cb?: () => void) => void;
        addGlobalHotkey: (keyArr: string[], handler: Function | any, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        removeAllHotkeys: (cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        removeGlobalHotkey: (keyArr: string[], handler: Function | any, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        addLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        removeLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./typedoc-types").StandardErrorCallback<void>) => import("./typedoc-types").StandardPromise<void>;
        addBrowserHotkey: (keyArr: string[], handler: () => void, addedByUser?: boolean) => void;
    };
    NotificationClient: {
        initialize: () => void;
        onReady: (cb?: any) => void;
        fetchHistory: (options?: import("./types").INotificationHistoryOptions | string, filter?: import("./types").IFilter) => Promise<import("./types").INotification[]>;
        getLastIssuedAt: (source?: string) => Promise<string>;
        performAction: (notifications: Partial<import("./types").INotification>[], action: import("./types").IAction) => Promise<void>;
        markRead: (notifications: import("./types").INotification[]) => Promise<void>;
        markUnread: (notifications: import("./types").INotification[]) => Promise<void>;
        deleteNotifications: (notifications: import("./types").INotification[]) => Promise<void>;
        notify: (notifications: Partial<import("./types").INotification>[] | Partial<import("./types").INotification>) => Promise<void>;
        subscribe: (subscription: Partial<import("./types").ISubscription>, onNotification: import("./types").OnNotificationCallback) => Promise<{
            id: string;
            channel: string;
        }>;
        unsubscribe: (subscriptionId: string) => Promise<void>;
        unsubscribeAll: () => void;
        mute: (filter: import("./types").IMuteFilter | import("./types").IMuteFilter[]) => Promise<void>;
        unmute: (filter: import("./types").IMuteFilter | import("./types").IMuteFilter[]) => Promise<void>;
        getPreferences: () => Promise<import("./types").NotificationServiceConfig>;
        getMuteFilters: () => Promise<import("./types").IMuteFilter[]>;
        getSources: () => Promise<string[]>;
        onClose: (cb?: () => void) => void;
        Notification: typeof import("./types").Notification;
        ActionTypes: typeof import("./types").ActionTypes;
        Subscription: typeof import("./types").Subscription;
        Action: typeof import("./types").Action;
        Filter: typeof import("./types").Filter;
        actionTypes: typeof import("./types").ActionTypes;
    };
};
//# sourceMappingURL=main.d.ts.map