@finsemble/finsemble-ui 10.0.0-beta.3 → 10.0.0-iocd.2

package/main.d.ts

@@ -0,0 +1,863 @@
+/**
+ * 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) | undefined) => Promise<void>;
+        onFailure: (cb?: (() => void) | undefined) => Promise<void>;
+        addListener: <T = any>(channel: string, eventHandler: import("./types").ListenerCallback<T>) => import("./types").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("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage<Q, R>>) => void;
+        query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
+            timeout?: number | undefined;
+            logWhenNoResponder?: boolean | undefined;
+        } | import("./types").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./types").QueryResponseCallback<R_1> | undefined) => Promise<import("./types").StandardQueryResponse<R_1>>;
+        removeResponder: (responderChannel: string) => void;
+        addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
+            subscribeCallback?: import("./types").SubscribeCallback<T_2> | undefined;
+            unsubscribeCallback?: import("./types").UnsubscribeCallback | undefined;
+            publishCallback?: import("./types").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("./typedoc-types").StandardError, response: import("./types").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("./types").RouterMessage<any>) => boolean;
+        disconnectAll: () => void;
+        calibrateTimeWithRouterService: (callback: (offset: number) => void) => void;
+    };
+    StorageClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        clearCache: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined, params?: {
+            topic: string;
+        } | undefined) => import("./typedoc-types").StandardPromise<void>;
+        remove: (params: {
+            key: string;
+            topic: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        getMultiple: (params: any, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        keys: (params: {
+            topic: string;
+            keyPrefix?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<string[]> | undefined) => import("./typedoc-types").StandardPromise<string[]>;
+        getStandardized: <T_5 = any>(params: {
+            key: string;
+            topic: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<T_5> | undefined) => import("./typedoc-types").StandardPromise<T_5>;
+        get: <T_6 = any>(params: {
+            key: string;
+            topic: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<T_6> | undefined) => Promise<T_6>;
+        save: (params: import("./types").ComponentMutateParams, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        setStore: (params: {
+            topic: string;
+            dataStore?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        setUser: (params: {
+            user: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-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("./typedoc-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[]>;
+    };
+    AppsClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        addToGroups: (params: {
+            windowIdentifier?: import("./types").WindowIdentifier | undefined;
+            groupNames?: string[] | undefined;
+        }, 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> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        addWindowsToGroup: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        bringWindowsToFront: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        clone: (toClone?: import("./types").WindowIdentifier | null | undefined, spawnParams?: import("./types").SpawnParams | null | undefined, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => Promise<{
+            error?: import("./typedoc-types").StandardError;
+            response?: import("./clients/appsClient").SpawnResponse | undefined;
+        }>;
+        createWindowGroup: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        getActiveAndPendingWindowNames: (cb?: Function) => Promise<{
+            err: any;
+            data: any;
+        }>;
+        getActiveDescriptors: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, import("./types").WindowDescriptor>> | undefined) => import("./typedoc-types").StandardPromise<Record<string, import("./types").WindowDescriptor>>;
+        getComponentDefaultConfig: (componentType: string, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentDescriptor> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentDescriptor>;
+        getComponentList: (cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentList> | undefined) => 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<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        getMonitorInfo: (params?: {
+            monitor?: import("./common/Monitors").MonitorCommand | undefined;
+            windowIdentifier?: import("./types").WindowIdentifier | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail> | undefined) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
+        getMonitorInfoAll: (cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail[]> | undefined) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail[]>;
+        getMyWindowIdentifier: (cb?: ((windowIdentifier: import("./types").WindowIdentifier) => void) | undefined) => Promise<import("./types").WindowIdentifier>;
+        getPendingWindows: () => import("./typedoc-types").StandardPromise<string[]>;
+        hyperFocus: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+            componentType?: string | undefined;
+        }, cb?: (() => void) | undefined) => Promise<void>;
+        minimizeWindows: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => 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 | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        removeWindowsFromGroup: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        showWindow: (windowLocator: import("./types").WindowLocator, params: any, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnResponse>;
+        spawn: (component: string, params: import("./types").SpawnParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => Promise<{
+            error?: import("./typedoc-types").StandardError;
+            response?: import("./clients/appsClient").SpawnResponse | undefined;
+        }>;
+        spawnTabCollection: ({ componentList, globalParams, }: {
+            componentList: {
+                appID: string;
+                individualParams?: import("./types").SpawnParams | undefined;
+            }[];
+            globalParams?: import("./types").TabbedGlobalSpawnParams | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnTabCollectionResponse> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnTabCollectionResponse>;
+        toggleWindowOnClick: (element: HTMLElement, windowLocator: import("./types").WindowLocator, params: any) => void;
+        unRegisterComponent: (params: {
+            componentType: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<string> | undefined) => import("./typedoc-types").StandardPromise<string>;
+        addApps: (apps: import("./types").FDC3AppDefinition[], cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
+        removeApps: (appIds: string[], cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<string[]>;
+        getApps: (appIds?: string[] | undefined, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
+    };
+    LauncherClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        addToGroups: (params: {
+            windowIdentifier?: import("./types").WindowIdentifier | undefined;
+            groupNames?: string[] | undefined;
+        }, 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[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        addWindowsToGroup: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        createWindowGroup: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+        }, cb?: Function) => Promise<unknown>;
+        minimizeWindows: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        hyperFocus: (params: {
+            windowList?: string[] | import("./types").WindowIdentifier[] | undefined;
+            groupName?: string | undefined;
+            componentType?: string | undefined;
+        }, cb?: (() => void) | undefined) => Promise<void>;
+        bringWindowsToFront: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        getComponentsThatCanReceiveDataTypes: (params: {
+            dataTypes: string[];
+        }, cb?: Function) => Promise<unknown>;
+        removeUserDefinedComponent: (params: {
+            name: string;
+            url?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        addUserDefinedComponent: (params: {
+            name: string;
+            url: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => 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>> | undefined) => import("./typedoc-types").StandardPromise<Record<string, import("./types").WindowDescriptor>>;
+        getMyWindowIdentifier: (cb?: ((windowIdentifier: import("./types").WindowIdentifier) => void) | undefined) => Promise<import("./types").WindowIdentifier>;
+        getMonitor: (windowIdentifier: import("./types").WindowIdentifier, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        spawn: (component: string, params: import("./types").SpawnParams, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => Promise<{
+            error?: import("./typedoc-types").StandardError;
+            response?: import("./clients/appsClient").SpawnResponse | undefined;
+        }>;
+        clone: (toClone?: import("./types").WindowIdentifier | null | undefined, spawnParams?: import("./types").SpawnParams | null | undefined, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => Promise<{
+            error?: import("./typedoc-types").StandardError;
+            response?: import("./clients/appsClient").SpawnResponse | undefined;
+        }>;
+        toggleWindowOnClick: (element: HTMLElement, windowLocator: import("./types").WindowLocator, params: any) => void;
+        showWindow: (windowLocator: import("./types").WindowLocator, params: any, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnResponse> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnResponse>;
+        unRegisterComponent: (params: {
+            componentType: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<string> | undefined) => 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 | undefined;
+            windowIdentifier?: import("./types").WindowIdentifier | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail> | undefined) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
+        getMonitorInfoAll: (cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail[]> | undefined) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail[]>;
+        getComponentDefaultConfig: (componentType: string, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentDescriptor> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentDescriptor>;
+        getComponentList: (cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").ComponentList> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").ComponentList>;
+        addApps: (apps: import("./types").FDC3AppDefinition[], cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
+        removeApps: (appIds: string[], cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<string[]>;
+        getApps: (appIds?: string[] | undefined, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<import("./types").FDC3AppDefinition[]>;
+        spawnTabCollection: ({ componentList, globalParams, }: {
+            componentList: {
+                appID: string;
+                individualParams?: import("./types").SpawnParams | undefined;
+            }[];
+            globalParams?: import("./types").TabbedGlobalSpawnParams | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./clients/appsClient").SpawnTabCollectionResponse> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/appsClient").SpawnTabCollectionResponse>;
+    };
+    DistributedStoreClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        createStore: (params: {
+            store: string;
+            global?: boolean | undefined;
+            persist?: boolean | undefined;
+            values?: any;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
+        getStore: (params: {
+            store: string;
+            global?: boolean | undefined;
+            waitForPersistentStoreToLoad?: boolean | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
+        createGlobalStore: (params: {
+            store: string;
+            persist?: boolean | undefined;
+            values?: any;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./types").StoreModel> | undefined) => import("./typedoc-types").StandardPromise<import("./types").StoreModel>;
+        removeStore: (params: {
+            store: string;
+            global?: boolean | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<boolean> | undefined) => 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: (params?: {
+            padding?: {
+                height: number;
+                width: number;
+            } | undefined;
+            maxHeight?: number | undefined;
+            maxWidth?: number | undefined;
+        } | null | undefined, cb?: (() => void) | undefined) => Promise<void>;
+        getBounds: (cb: import("./typedoc-types").StandardErrorCallback<import("./types").Bounds>) => import("./typedoc-types").StandardPromise<import("./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("./types").WindowIdentifier | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<import("./FEA").MonitorInfoDetail> | undefined) => import("./typedoc-types").StandardPromise<import("./FEA").MonitorInfoDetail>;
+        cancelTilingOrTabbing: (params: {
+            windowIdentifier?: import("./types").WindowIdentifier | undefined;
+        }, cb?: (() => void) | undefined) => void;
+        startTilingOrTabbing: (params: {
+            windowIdentifier: import("./types").WindowIdentifier;
+        }, cb?: (() => void) | undefined) => void;
+        stopTilingOrTabbing: (params: {
+            mousePosition?: {
+                x: number;
+                y: number;
+            } | undefined;
+            action?: string | undefined;
+            allowDropOnSelf?: boolean | undefined;
+        }, 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("./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;
+        addListeners: () => void;
+        formGroup: () => void;
+        getTabCollection: ({ id }: {
+            id: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<{
+            windows: string[];
+            promotedWindowName: string;
+        }> | undefined) => import("./typedoc-types").StandardPromise<{
+            windows: string[];
+            promotedWindowName: string;
+        }>;
+        getWindowNameForDocking: () => string;
+        removeComponentState: (params: {
+            field?: string | undefined;
+            fields?: {
+                field: string;
+            }[] | undefined;
+            windowName?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-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("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        getComponentState: <T_9 = any>(params: {
+            field?: string | undefined;
+            fields?: string[] | undefined;
+            windowName?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<T_9> | undefined) => import("./typedoc-types").StandardPromise<T_9>;
+        injectDOM: (headerHeight: number) => void;
+        setTaskbarIconOverlay: (url: string | null) => void;
+        restore: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        setAlwaysOnTop: (alwaysOnTop: boolean, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        bringWindowToFront: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => void;
+        bringToFront: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        minimize: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        maximize: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        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: (windowName?: string | undefined) => Promise<string | null>;
+        close: (params?: {
+            removeFromWorkspace: boolean;
+            closeWindow: boolean;
+            userInitiated?: boolean | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        addToTabCollection: ({ windowNames, tabCollectionId, position, promotedTab, }: {
+            windowNames: string[];
+            tabCollectionId: string;
+            position?: number | undefined;
+            promotedTab?: string | undefined;
+        }) => Promise<void>;
+        createTabCollection: ({ windowNames, promotedTab, }: {
+            windowNames: string[];
+            promotedTab?: string | undefined;
+        }) => Promise<void>;
+        removeFromTabCollection: ({ windowNames }: {
+            windowNames: string[];
+        }) => Promise<void>;
+        promoteTab: (windowName: string) => Promise<void>;
+        getPromotedTab: ({ tabCollectionId }: {
+            tabCollectionId: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<string> | undefined) => import("./typedoc-types").StandardPromise<string>;
+        getTabCollectionForWindow: ({ windowName }: {
+            windowName: string;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<{
+            id: string;
+            windows: string[];
+        }> | undefined) => import("./typedoc-types").StandardPromise<{
+            id: string;
+            windows: string[];
+        }>;
+    };
+    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, string | import("./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("./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;
+        }> | undefined) => Promise<{
+            data: import("./types").Workspace;
+        }>;
+        saveAs: (params: {
+            name: string;
+            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("./typedoc-types").StandardErrorCallback<string[]> | undefined) => Promise<string[]>;
+        getWorkspaceActions: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, string>> | undefined) => Record<string, string>;
+        getWorkspaces: (cb?: Function | undefined) => Promise<unknown>;
+        getActiveWorkspace: (cb?: import("./typedoc-types").StandardErrorCallback<{
+            data: import("./types").Workspace;
+        }> | undefined) => Promise<{
+            data: import("./types").Workspace;
+        }>;
+        bringWindowsToFront: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        minimizeAll: (params?: {
+            windowList?: string[] | undefined;
+        } | undefined, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        autoArrange: (params: any, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => 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<any, any> | null;
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        createStore: (cb?: (() => void) | undefined) => Promise<void>;
+        getAvailableDialog: (type: string, cb?: ((dialog: import("./types").WindowIdentifier | null) => void) | undefined) => 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> | undefined) => import("./typedoc-types").StandardPromise<import("./clients/launcherClient").SpawnResponse>;
+        registerDialogCallback: (cb?: import("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage<any, any>> | undefined) => Promise<void>;
+        getParametersFromInDialog: () => Promise<any>;
+        respondAndExitFromInDialog: (responseParameters: any) => Promise<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("./types").SpawnParams | undefined;
+        }, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        completeOAUTH: (err?: string | null | undefined, params?: any, cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        transmitSignOnToAuthService: (signOnData: import("./clients/authenticationClient").SignOnData) => void;
+        getCurrentCredentials: (cb?: import("./typedoc-types").StandardErrorCallback<any> | undefined) => import("./typedoc-types").StandardPromise<any>;
+        publishAuthorization: (user: string, credentials: any) => void;
+        appRejectAndRetrySignOn: (signOnKey: string, params: {
+            userMsg?: string | undefined;
+        }, cb: import("./typedoc-types").StandardCallback<import("./typedoc-types").StandardError, any>) => void;
+        appRejectSignOn: (signOnKey: any) => void;
+        appAcceptSignOn: (signOnKey: any) => void;
+        appSignOn: (signOnKey: string, params: {
+            icon: string;
+            prompt: string;
+            force: boolean;
+            userMsg?: string | undefined;
+        }, cb?: import("./typedoc-types").StandardCallback<import("./typedoc-types").StandardError, any> | undefined) => 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_10 = any>(params: import("./types").PathArray | {
+            field: string | null;
+        }, fn: import("./types").ListenerFunction<T_10>, cb?: (() => void) | undefined) => Promise<void>;
+        addListeners: <T_11 = any>(params: string[] | import("./types").ListenerParam[] | import("./types").PathArrayListenerParam[], fn: import("./types").ListenerFunction<T_11>, cb?: (() => void) | undefined) => Promise<void> | undefined;
+        getManifest: (cb?: import("./typedoc-types").StandardErrorCallback<import("./typedoc-types").Manifest> | undefined) => import("./typedoc-types").StandardPromise<import("./typedoc-types").Manifest>;
+        getPreferences: (cb?: import("./typedoc-types").StandardErrorCallback<Record<string, any> | null> | undefined) => import("./typedoc-types").StandardPromise<Record<string, any> | null>;
+        getValue: <T_12 = any>(params: string | import("./types").FieldOnlyParam, cb?: import("./typedoc-types").StandardErrorCallback<T_12> | undefined) => import("./typedoc-types").StandardPromise<T_12>;
+        getValues: <T_13 = any>(fields?: string[] | import("./types").FieldOnlyParam[] | null | undefined, cb?: import("./typedoc-types").StandardErrorCallback<Record<string, T_13>> | undefined) => import("./typedoc-types").StandardPromise<Record<string, T_13>>;
+        processAndSet: (params: {
+            newConfig: Record<string, any>;
+            overwrite: boolean;
+            replace: boolean;
+        }, cb?: import("./clients/configClient").ProcessAndSetCallback | undefined) => import("./typedoc-types").StandardPromise<import("./typedoc-types").Manifest>;
+        removeListener: (params: import("./types").PathArray | {
+            field: string | null;
+        }, fn: import("./types").ListenerFunction<any>, cb?: Function | undefined) => void;
+        removeListeners: (params: import("./types").RemoveListenersType, fn?: import("./types").ListenerFunction<any> | undefined, cb?: import("./typedoc-types").StandardErrorCallback<boolean> | undefined) => void;
+        removeValue: <T_14 = any>(params: string | import("./types").FieldOnlyParam, cb?: import("./typedoc-types").StandardErrorCallback<T_14> | undefined) => import("./typedoc-types").StandardPromise<T_14>;
+        removeValues: (fields: string[] | import("./types").FieldOnlyParam[], cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => Promise<{
+            err: string | null | undefined;
+        }>;
+        setPreference: (params: import("./types").FieldAndValueParam, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        setValue: (params: import("./types").FieldAndValueParam, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => Promise<{
+            err: string | null | undefined;
+        }>;
+        setValues: (fields: import("./types").FieldAndValueParams, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => Promise<{
+            err: string | null | undefined;
+        }>;
+        unsetPreference: (params: import("./types").FieldOnlyParam, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        get: <T_15 = any>(path: import("./types").PathArray | null, cb?: import("./typedoc-types").StandardErrorCallback<T_15> | undefined) => import("./typedoc-types").StandardPromise<T_15>;
+        getMultiple: <T_16 = any>(paths: import("./types").PathArray[], cb?: import("./typedoc-types").StandardErrorCallback<T_16> | undefined) => import("./typedoc-types").StandardPromise<T_16>;
+        set: <T_17 = any>(path: import("./types").PathArray, value: any, cb?: import("./typedoc-types").StandardErrorCallback<T_17> | undefined) => import("./typedoc-types").StandardPromise<T_17>;
+        setMultiple: <T_18 = any>(pathsAndValues: import("./types").FieldPathArrayAndValue[], cb?: import("./typedoc-types").StandardErrorCallback<T_18> | undefined) => import("./typedoc-types").StandardPromise<T_18>;
+        remove: <T_19 = any>(path: import("./types").PathArray, cb?: import("./typedoc-types").StandardErrorCallback<T_19> | undefined) => import("./typedoc-types").StandardPromise<T_19>;
+        removeMultiple: <T_20 = any>(paths: import("./types").PathArray[], cb?: import("./typedoc-types").StandardErrorCallback<T_20> | undefined) => import("./typedoc-types").StandardPromise<T_20>;
+    };
+    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>;
+            onFailure: (cb?: (() => void) | undefined) => Promise<void>;
+            addListener: <T = any>(channel: string, eventHandler: import("./types").ListenerCallback<T>) => import("./types").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("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage<Q, R>>) => void;
+            query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
+                timeout?: number | undefined;
+                logWhenNoResponder?: boolean | undefined;
+            } | import("./types").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./types").QueryResponseCallback<R_1> | undefined) => Promise<import("./types").StandardQueryResponse<R_1>>;
+            removeResponder: (responderChannel: string) => void;
+            addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
+                subscribeCallback?: import("./types").SubscribeCallback<T_2> | undefined;
+                unsubscribeCallback?: import("./types").UnsubscribeCallback | undefined;
+                publishCallback?: import("./types").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("./typedoc-types").StandardError, response: import("./types").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("./types").RouterMessage<any>) => boolean;
+            disconnectAll: () => void;
+            calibrateTimeWithRouterService: (callback: (offset: number) => void) => void;
+        } | undefined) => void;
+        channelFilter: (channel: string) => boolean;
+        setting: () => import("./types").CentralLoggerClientState;
+        callStack: () => string;
+        unregisterClient: (params?: {
+            clientName: string;
+            deleteFromPersistence?: boolean | undefined;
+            viewId?: number | undefined;
+        } | undefined, cb?: ((err: import("./typedoc-types").StandardError, data?: any) => void) | undefined) => void;
+        setRouterClient: (routerClient: {
+            onReady: (cb?: (() => void) | undefined) => Promise<void>;
+            onFailure: (cb?: (() => void) | undefined) => Promise<void>;
+            addListener: <T = any>(channel: string, eventHandler: import("./types").ListenerCallback<T>) => import("./types").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("./typedoc-types").StandardErrorCallback<import("./types").ResponderMessage<Q, R>>) => void;
+            query: <Q_1 = any, R_1 = any>(responderChannel: string, queryEvent: Q_1, queryParams?: {
+                timeout?: number | undefined;
+                logWhenNoResponder?: boolean | undefined;
+            } | import("./types").QueryResponseCallback<R_1> | undefined, responseEventHandler?: import("./types").QueryResponseCallback<R_1> | undefined) => Promise<import("./types").StandardQueryResponse<R_1>>;
+            removeResponder: (responderChannel: string) => void;
+            addPubSubResponder: <T_2 = any>(topic: string | RegExp, initialState?: object | undefined, params?: {
+                subscribeCallback?: import("./types").SubscribeCallback<T_2> | undefined;
+                unsubscribeCallback?: import("./types").UnsubscribeCallback | undefined;
+                publishCallback?: import("./types").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("./typedoc-types").StandardError, response: import("./types").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("./types").RouterMessage<any>) => boolean;
+            disconnectAll: () => void;
+            calibrateTimeWithRouterService: (callback: (offset: number) => void) => void;
+        }) => 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 | 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("./typedoc-types").StandardErrorCallback<{
+            status: string;
+        }> | undefined) => import("./typedoc-types").StandardPromise<{
+            status: string;
+        }>;
+    };
+    HotkeyClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        onClose: (cb?: (() => void) | undefined) => void;
+        addGlobalHotkey: (keyArr: string[], handler: any, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        removeAllHotkeys: (cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        removeGlobalHotkey: (keyArr: string[], handler: any, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        addLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        removeLocalHotkey: (keyArr: string[], handler: (...args: any[]) => void, cb?: import("./typedoc-types").StandardErrorCallback<void> | undefined) => import("./typedoc-types").StandardPromise<void>;
+        addBrowserHotkey: (keyArr: string[], handler: () => void, addedByUser?: boolean | undefined) => void;
+    };
+    NotificationClient: {
+        initialize: () => void;
+        onReady: (cb?: any) => void;
+        fetchHistory: (options?: string | import("./types").INotificationHistoryOptions | undefined, filter?: import("./types").IFilter | undefined) => Promise<import("./types").INotification[]>;
+        getLastIssuedAt: (source?: string | undefined) => 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) | undefined) => 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