import { FinsembleWindow } from "../common/FinsembleWindow";
import { SpawnParams, TabbedGlobalSpawnParams } from "../platform/services/window/types";
import { StandardError, StandardErrorCallback, StandardPromise } from "../types";
import { WindowIdentifier, WindowDescriptor, WindowLocator, ShowWindowParams } from "../platform/services/window/types";
import { MonitorCommand, MonitorInfoDetail } from "../common/Monitors";
import { FDC3AppDefinition } from "../platform/services/Interop/types";
export type ComponentDescriptor = Record<string, any>;
export type ComponentList = Record<string, ComponentDescriptor>;
export type MonitorInfo = any;
export type SpawnResponse = {
    windowDescriptor: WindowDescriptor;
    windowIdentifier: WindowIdentifier;
    launchGroupWindows?: string[];
    /**
     * @internal
     */
    finWindow: FinsembleWindow;
};
export type SpawnTabCollectionResponse = {
    id: string;
    windows: SpawnResponse[];
};
export { MonitorInfoDetail, MonitorCommand, WindowDescriptor, WindowIdentifier, SpawnParams, WindowLocator };
export { MonitorCoordinates, MonitorInfoTaskbarDetails, MonitorRectDetails } from "../FEA";
export { IconDescriptor, IconUrl, IconInitials, CompositeComponentData, LaunchGroupComponentData, MonitorChoice, SpawnOptions, PositionTypes, WindowInterop, WindowTypes, AppIcons, ConnectId, } from "../platform/services/window/types";
/**
 * @language javascript, dotnet
 * Get a list of registered components from <i>components.json</i>.
 *
 * ```javascript
 * const {err, data} = await FSBL.Clients.AppsClient.getComponentList();
 * if(!err){
 * 	 console.log(data);
 *   // {
 *   //   "Toolbar": { ... },
 *   //   "Tour": { ... },
 *   //   ...
 *   // }
 * }
 * ```
 *
 * @param cb Callback returns an object map of components. Each component object
 * contains the default config for that component.
 */
export declare const getComponentList: (cb?: StandardErrorCallback<ComponentList>) => StandardPromise<ComponentList>;
/**
 * @language javascript, dotnet
 * Get the component config for a specific component from <i>components.json</i>.
 *
 * ```javascript
 * const {err, data} = await FSBL.Clients.AppsClient.getComponentDefaultConfig("ChartIQ Example App");
 * ```
 *
 * @param componentType The type of the component.
 * @param cb Callback returns the default config (windowDescriptor) for the requested componentType.
 */
export declare const getComponentDefaultConfig: (componentType: string, cb?: StandardErrorCallback<ComponentDescriptor>) => StandardPromise<ComponentDescriptor>;
/**
 * @language javascript, dotnet
 * Get monitorInfo (dimensions and position) for all monitors. Returns an array of monitorInfo objects. See <a href="/docs/reference/typedocs/modules/AppsClient#getMonitorInfo">AppsClient#getMonitorInfo</a> for the format of a monitorInfo object.
 *
 * ```javascript
 * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfoAll();
 * if(!err){
 *   console.log(`There are ${data.length} monitors.`);
 * }
 * ```
 *
 * @param cb Returns an array of monitorInfo objects.
 */
export declare const getMonitorInfoAll: (cb?: StandardErrorCallback<MonitorInfoDetail[]>) => StandardPromise<MonitorInfoDetail[]>;
/**
 * @language javascript, dotnet
 * Get monitor information for a given windowIdentifier or for a specific monitor.
 * If neither the identifier nor monitor are provided, returns the monitorInfo for the current window.
 *
 *
 * The information returned contains:
 *
 * **monitorRect** - The full dimensions for the monitor. <br/>
 * **availableRect** - The dimensions for the available space on the monitor (not including the Windows task bar). <br/>
 * **position** - A number that represents the position of the monitor. The primary monitor is zero. <br/>
 * **whichMonitor** - Contains the string "primary" if it is the primary monitor. <br/>
 *
 * The dimensions are supplemented with the following additional members:
 *
 * **width** - The width calculated as right - left. <br/>
 * **height** - The height calculated as bottom - top. <br/>
 *
 * ```javascript
 * // Get the info for the monitor that the calling app is on
 * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo();
 * if(!err){
 *   console.log(data);
 * // Example results:
 * // {
 * //	availableRect: {width, height, bottom, left, ...},
 * //   deviceId: "123456",
 * //   deviceScaleFactor: 2,
 * //   displayDeviceActive: true,
 * //   monitor: {dipRect, scaledRect},
 * //   monitorRect: {width, height, bottom, left, right, ...}
 * //   name: "device0",
 * //   position: 0,
 * //   taskbar: {top, left, right, bottom, width, ...}
 * //   whichMonitor: "primary"
 * // }
 * }
 *
 * // Get monitor info for a given window
 * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({
 *   windowIdentifier: {
 *     windowName: "ABC-uuid"
 *   }
 * });
 * if(!err){
 *   console.log(`App ABC-uuid is currently on the monitor with index ${data.position}`);
 * }
 *
 * // Get the dimensions of the first non-primary monitor
 * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({monitor: 1});
 * if(!err){
 *   console.log("Available dimensions for monitor[1]: ", data.monitorRect);
 *   console.log("Available dimensions, minus claimed space, for monitor[1]: ", data.availableRect);
 * }
 * ```
 *
 * @param params
 * @param params.windowIdentifier The windowIdentifier to get the monitorInfo. If undefined, this points to the current window.
 * @param params.monitor If passed then a specific monitor is identified. Valid values include:
 *
 * <b>"mine"</b> - Place the window on the same monitor as the calling window.
 *
 * Integer value from 0-n (0 being the primary monitor).
 *
 * <b>"primary"</b> indicates the user's primary monitor.
 *
 * <b>"all"</b> - Put a copy of the component on each monitor.
 * @param cb Returns a monitorInfo object containing the monitorRect and availableRect.
 *
 * @returns A promise that resolves to a monitorInfo.
 */
export declare const getMonitorInfo: (params?: {
    monitor?: MonitorCommand;
    windowIdentifier?: WindowIdentifier;
}, cb?: StandardErrorCallback<MonitorInfoDetail>) => StandardPromise<MonitorInfoDetail>;
/**
 * @language javascript, dotnet
 * Displays a window and relocates/resizes it according to the values contained in parameters. If the specified window is in a group or tabbed, it is unsnapped/ungrouped/untabbed from the other windows.
 * If invoked on a tabbed window or a window in a group, the window is removed from the tab/group.
 *
 * Caution: A window can inherit parameters only once, at the time when it’s spawned. When the component already exists, changing parameters other than positioning arguments (monitor, relativeWindow, top, bottom, left, right, width, height) has no effect.
 *
 * ```javascript
 * FSBL.Clients.AppsClient.showWindow({windowName: "Welcome Component-86-3416-Finsemble", componentType: "Welcome Component"}, {spawnIfNotFound: true}, (err, data)=> {});
 * ```
 * @param windowIdentifier A windowIdentifier. This is an object containing windowName and componentType. If you don't specify windowName, Finsemble tries to find it by componentType.
 * @param params Configuration settings from the <i><a href="/docs/reference/ConfigReference#finsemble-appd---manifest-window">finsemble.appd[].manifest.window</a></i> section of the application manifest may be used as parameters to this function, except for the `options` element.
 * These are the same as <a href="/docs/reference/typedocs/modules/AppsClient#spawn">AppsClient.spawn()</a> with the following exceptions:
 * <ul>
 * 	<li><b>monitor</b> - Same as spawn() except that null or undefined means don't move the window to a different monitor.</li>
 *  <li><b>left</b> - Same as spawn() except that null or undefined means don't move the window from current horizontal location.</li>
 *  <li><b>top</b> - Same as spawn() except that null or undefined means don't move the window from current vertical location.</li>
 *  <li><b>slave</b> - Cannot be set for an existing window. Goes into effect only if the window is spawned. In other words, use this only in conjunction with spawnIfNotFound.</li>
 *  <li><b>spawnIfNotFound</b> - If true, spawns a new window if the requested one cannot be found. Note: only works if the windowIdentifier contains a componentType.</li>
 *  <li><b>autoFocus</b> - Whether or not the window should be in focus when shown.</li>
 * </ul>
 * @param cb Callback to be invoked after the function is completed regardless of whether the call fails or succeeds.
 * Callback contains two arguments in the following order:
 * <ol>
 * 	<li><b>error</b>: an object containing details related to the reason the call failed and where the exception occurred. This object is null if the call has succeeded.</li>
 * 	<li><b>data</b>: an object with the following information:
 * 		<ul>
 * 			<li><b>windowIdentifier</b> - The <a href="/docs/productivity/componentTypesAndWindowNames">WindowIdentifier</a> for the new window.</li>
 * 			<li><b>windowDescriptor</b> - The <a href="/docs/productivity/componentTypesAndWindowNames">WindowDescriptor</a> of the new window.</li>
 * 			<li><b>finWindow</b> - A <code>finWindow</code> object referencing the new window.</li>
 * 		</ul>
 * 	</li>
 * </ol>
 */
export declare const showWindow: (windowLocator: WindowLocator, params: ShowWindowParams, cb?: StandardErrorCallback<SpawnResponse>) => StandardPromise<SpawnResponse>;
/**
 * @language javascript
 * A convenient method for dealing with a common use case of toggling the appearance and disappearance of a child window when a user presses a button of a dropdown menus.
 * Call this method from the click handler for your element. Your child window needs to close itself on blur events.
 * Caution: A window can inherit parameters only once, at the time when it’s spawned. When the component already exists, changing parameters other than positioning arguments (monitor, relativeWindow, top, bottom, left, right, width, height) has no effect.
 * @param element The DOM element, or selector, clicked by the end user.
 * @param windowIdentifier Identifies the child window
 * @param params Parameters to be passed to <a href="/docs/reference/typedocs/modules/AppsClient#showWindow">AppsClient.showWindow()</a> if the child window is allowed to open
 */
export declare const toggleWindowOnClick: (element: HTMLElement, windowLocator: WindowLocator, params: ShowWindowParams) => void;
/**
 * @language javascript, dotnet
 * Asks the Launcher service to spawn a new component. You can also specify any of the following parameters in <i>public/config/components.json</i>, which will
 * then operate as the default for that value.
 *
 * The launcher parameters mimic CSS window positioning.
 * For example, to set a full screen window, use `{left: 0, top: 0, right: 0, bottom: 0}`.
 * This is functionally equivalent to `{left: 0, top: 0, width: "100%", height: "100%"}`.
 *
 * You can also spawn more than one component at a time by using a single action, such as clicking a button on a menu.
 * See https://github.com/ChartIQ/finsemble-seed/tree/recipes/SpawnComponentGroup for an example of spawning a component group.
 *
 * ```javascript
 * FSBL.Clients.AppsClient.spawn("Welcome Component", {left: 0, top: 0, position: "relative"}, (err, data)=> {});
 * ```
 * @param component The application or component to spawn.
 * @param params Configuration settings from the <i><a href="/docs/reference/ConfigReference#finsemble-appd---manifest-window">finsemble.appd[].manifest.window</a></i> section of the application manifest may be used as parameters to this function, except for the `options` element.
 * @param cb Function invoked after the window is created
 */
export declare const spawn: (component: string, params: SpawnParams, cb?: StandardErrorCallback<SpawnResponse>) => Promise<{
    error?: StandardError;
    response?: SpawnResponse;
}>;
/**
 * @language javascript, dotnet
 * Clone an existing component. Will clone the calling window if no window is specified. Cannot clone freestanding or singleton components.
 *
 * ```javascript
 * FSBL.Clients.AppsClient.clone({windowName:"window-to-clone"}, {left: 0, top: 0}, (err, data) => {});
 * ```
 *
 * @param toClone An optional WindowIdentifier of the window to clone. If you don't provide this parameter,
 * Finsemble tries to clone the calling window.
 * @param spawnParams Optional spawn parameters that override the cloned window params on spawn.
 * @param cb An optional callback that is called when spawn has completed.
 */
export declare const clone: (toClone?: WindowIdentifier | null, spawnParams?: SpawnParams | null, cb?: StandardErrorCallback<SpawnResponse>) => Promise<{
    error?: StandardError;
    response?: SpawnResponse;
}>;
/**
 * @language javascript, dotnet
 * Spawns a set of apps and assembles them into a tab collection. you can specify spawn parameters for the entire collection
 * or for individual apps. However, positioning parameters (e.g. `left` or `top`) are disregarded when set on individual apps.
 *
 * ```javascript
 * await FSBL.Clients.AppsClient.spawnTabCollection({
 *		componentList: [{appID: "Welcome Component", individualParams: { alwaysOnTop : true } }],
 *		globalParams: { left: 100, top: 100}
 *	});
 * ```
 * @param __namedParameters.componentList - The apps to open. Each should be an object that contains the appID (from AppD) and an optional set of SpawnParams.
 * @param __namedParameters.globalParams - Positioning parameters for the collection. If omitted, the collection is spawned in a default location.
 * @returns - Resolves to an object that contains the ID of the tab collection and the list of window names for the spawned apps
 */
export declare const spawnTabCollection: ({ componentList, globalParams, }: {
    componentList: {
        appID: string;
        individualParams?: SpawnParams;
    }[];
    globalParams?: TabbedGlobalSpawnParams;
}, cb?: StandardErrorCallback<SpawnTabCollectionResponse>) => StandardPromise<SpawnTabCollectionResponse>;
/**
 * @language javascript, dotnet
 * Returns a windowIdentifier for the current window.
 *
 * ```javascript
 * const myWindowIdentifier = await FSBL.Clients.AppsClient.getMyWindowIdentifier();
 * console.log(myWindowIdentifier);
 * // {
 * //   windowName: "ABC-uuid",
 * //   componentType: "ABC"
 * // }
 * ```
 *
 * @param cb Callback function returns windowIdentifier for this window. (Optional or use the returned Promise)
 * @returns A promise that resolves to a windowIdentifier.
 */
export declare const getMyWindowIdentifier: (cb?: (windowIdentifier: WindowIdentifier) => void) => Promise<WindowIdentifier>;
/**
 * @language javascript, dotnet
 * Gets the windowDescriptor for all open windows.
 *
 * :::note
 * This returns descriptors even if the window is not part of the workspace.
 * :::
 *
 * ```javascript
 * FSBL.Clients.AppsClient.getActiveDescriptors(function (error, response) {
 * 	if (error) {
 *		Logger.system.error("Error getting active descriptors: ",  + JSON.stringify(error));
 *	} else {
 *		const activeDescriptors = response;
 *		//{
 *		//	...
 *		//	Toolbar-1-Finsemble: {...},
 *		//	Welcome-Component-80-6453-Finsemble: {...},
 *		//	...
 *		//}
 * 	}
 * });
 * ```
 * @param cb Callback returns an object containing windowDescriptors keyed by name.
 */
export declare const getActiveDescriptors: (cb?: StandardErrorCallback<Record<string, WindowDescriptor>>) => StandardPromise<Record<string, WindowDescriptor>>;
/**
 * @private Adds a custom component.
 * @ignore
 */
export declare const addUserDefinedComponent: (params: {
    name: string;
    url: string;
}, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
/**
 * @private Adds a custom component.
 * @ignore
 */
export declare const removeUserDefinedComponent: (params: {
    name: string;
    url?: string;
}, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
/**
 * @language javascript, dotnet
 * Adds to Finsemble new FDC3 App definition(s), in the form of an array of FDC3 2.0 AppD
 * records. After the apps are added, a user can launch them via the Apps
 * Client, `fdc3.open`, `fdc3.raiseIntent` or Toolbar launcher menus.
 *
 * ```javascript
 * const {err, data} = await FSBL.Clients.AppsClient.addApps([anFDC3App]);
 * ```
 *
 * You can update apps by correlating the appIds. Example:
 * ```javascript
 * // Get MyApp
 * const { data: apps } = await FSBL.Clients.AppsClient.getApps(["MyApp"]);
 * const myApp = apps[0];
 *
 * // Update MyApp name to "My App New Name"
 * app.name = `MyApp New Name`;
 *
 * // Update the app in Finsemble
 * await FSBL.Clients.AppsClient.addApps([app]);
 * ```
 *
 * @param apps he array of FDC3 2.0 AppD records (`FDC3AppDefinition`) to add to Finsemble.
 * @param cb The callback to be invoked after the apps are set or on error.
 * @returns A promise that resolves to an array of the added app objects.
 */
export declare const addApps: (apps: FDC3AppDefinition[], cb?: StandardErrorCallback) => StandardPromise<FDC3AppDefinition[]>;
/**
 * @language javascript, dotnet
 * Removes from Finsemble one or more apps,specified via an array of `appId` values.
 * After an app is removed, it can no longer be launched via the
 * AppsClient, `fdc3.open`, `fdc3.raiseIntent` or launcher menus. Removed
 * applications are automatically removed from launcher menus.
 *
 * Existing instances of the apps are NOT closed automatically when removed,
 * either from the current workspace or saved workspaces. However, saved
 * workspaces containing them are unable to launch them when the workspace
 * is loaded.
 *
 * ```javascript
 * const {err, data} = await FSBL.Clients.AppsClient.removeApps(["fdc3AppId"]);
 * ```
 *
 * @param apps The array of appIds to remove
 * @param cb The callback to be invoked after the apps are removed or on error.
 * @returns A promise that resolves to an array of the removed appId strings.
 */
export declare const removeApps: (appIds: string[], cb?: StandardErrorCallback) => StandardPromise<string[]>;
/**
 * @language javascript, dotnet
 * Retrieves the AppD records for a specified list `appIds` known to Finsemble.
 *
 * @param appIds an array of app IDs to retrieve. If not provided, Finsemble retrieves all apps.
 * @param cb The callback to be invoked after the apps are retrieved or on error.
 * @returns A promise that resolves to an array of app objects.
 */
export declare const getApps: (appIds?: string[], cb?: StandardErrorCallback) => StandardPromise<FDC3AppDefinition[]>;
/**
 * @ignore
 */
export declare const AppsClient: {
    /**
     * For backward compatibility
     * @private
     * @deprecated
     */
    initialize: () => void;
    /**
     * For backward compatibility
     * @private
     * @deprecated
     */
    onReady: (cb?: any) => void;
    addToGroups: (params: {
        windowIdentifier?: WindowIdentifier;
        groupNames?: string[];
    }, cb: (err?: StandardError) => void) => Promise<{
        err: StandardError;
    }>;
    addUserDefinedComponent: (params: {
        name: string;
        url: string;
    }, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
    addWindowsToGroup: (params: {
        windowList?: string[] | WindowIdentifier[];
        groupName?: string;
    }, cb?: Function) => Promise<unknown>;
    bringWindowsToFront: (params?: {
        windowList?: string[];
    }, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
    clone: (toClone?: WindowIdentifier | null, spawnParams?: SpawnParams | null, cb?: StandardErrorCallback<SpawnResponse>) => Promise<{
        error?: StandardError;
        response?: SpawnResponse;
    }>;
    createWindowGroup: (params: {
        windowList?: string[] | WindowIdentifier[];
        groupName?: string;
    }, cb?: Function) => Promise<unknown>;
    getActiveAndPendingWindowNames: (cb?: Function) => Promise<{
        err: any;
        data: any;
    }>;
    getActiveDescriptors: (cb?: StandardErrorCallback<Record<string, WindowDescriptor>>) => StandardPromise<Record<string, WindowDescriptor>>;
    getComponentDefaultConfig: (componentType: string, cb?: StandardErrorCallback<ComponentDescriptor>) => StandardPromise<ComponentDescriptor>;
    getComponentList: (cb?: StandardErrorCallback<ComponentList>) => StandardPromise<ComponentList>;
    getComponentsThatCanReceiveDataTypes: (params: {
        dataTypes: string[];
    }, cb?: Function) => Promise<unknown>;
    getGroupsForWindow: (params: {
        windowIdentifier: WindowIdentifier;
    } | null, cb?: Function) => Promise<unknown>;
    getMonitor: (windowIdentifier: WindowIdentifier, cb?: StandardErrorCallback<MonitorInfo>) => StandardPromise<MonitorInfo>;
    getMonitorInfo: (params?: {
        monitor?: MonitorCommand;
        windowIdentifier?: WindowIdentifier;
    }, cb?: StandardErrorCallback<MonitorInfoDetail>) => StandardPromise<MonitorInfoDetail>;
    getMonitorInfoAll: (cb?: StandardErrorCallback<MonitorInfoDetail[]>) => StandardPromise<MonitorInfoDetail[]>;
    getMyWindowIdentifier: (cb?: (windowIdentifier: WindowIdentifier) => void) => Promise<WindowIdentifier>;
    getPendingWindows: () => StandardPromise<string[]>;
    hyperFocus: (params: {
        windowList?: string[] | WindowIdentifier[];
        groupName
        /**
         * @language javascript, dotnet
         * Get monitor information for a given windowIdentifier or for a specific monitor.
         * If neither the identifier nor monitor are provided, returns the monitorInfo for the current window.
         *
         *
         * The information returned contains:
         *
         * **monitorRect** - The full dimensions for the monitor. <br/>
         * **availableRect** - The dimensions for the available space on the monitor (not including the Windows task bar). <br/>
         * **position** - A number that represents the position of the monitor. The primary monitor is zero. <br/>
         * **whichMonitor** - Contains the string "primary" if it is the primary monitor. <br/>
         *
         * The dimensions are supplemented with the following additional members:
         *
         * **width** - The width calculated as right - left. <br/>
         * **height** - The height calculated as bottom - top. <br/>
         *
         * ```javascript
         * // Get the info for the monitor that the calling app is on
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo();
         * if(!err){
         *   console.log(data);
         * // Example results:
         * // {
         * //	availableRect: {width, height, bottom, left, ...},
         * //   deviceId: "123456",
         * //   deviceScaleFactor: 2,
         * //   displayDeviceActive: true,
         * //   monitor: {dipRect, scaledRect},
         * //   monitorRect: {width, height, bottom, left, right, ...}
         * //   name: "device0",
         * //   position: 0,
         * //   taskbar: {top, left, right, bottom, width, ...}
         * //   whichMonitor: "primary"
         * // }
         * }
         *
         * // Get monitor info for a given window
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({
         *   windowIdentifier: {
         *     windowName: "ABC-uuid"
         *   }
         * });
         * if(!err){
         *   console.log(`App ABC-uuid is currently on the monitor with index ${data.position}`);
         * }
         *
         * // Get the dimensions of the first non-primary monitor
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({monitor: 1});
         * if(!err){
         *   console.log("Available dimensions for monitor[1]: ", data.monitorRect);
         *   console.log("Available dimensions, minus claimed space, for monitor[1]: ", data.availableRect);
         * }
         * ```
         *
         * @param params
         * @param params.windowIdentifier The windowIdentifier to get the monitorInfo. If undefined, this points to the current window.
         * @param params.monitor If passed then a specific monitor is identified. Valid values include:
         *
         * <b>"mine"</b> - Place the window on the same monitor as the calling window.
         *
         * Integer value from 0-n (0 being the primary monitor).
         *
         * <b>"primary"</b> indicates the user's primary monitor.
         *
         * <b>"all"</b> - Put a copy of the component on each monitor.
         * @param cb Returns a monitorInfo object containing the monitorRect and availableRect.
         *
         * @returns A promise that resolves to a monitorInfo.
         */
        ? /**
         * @language javascript, dotnet
         * Get monitor information for a given windowIdentifier or for a specific monitor.
         * If neither the identifier nor monitor are provided, returns the monitorInfo for the current window.
         *
         *
         * The information returned contains:
         *
         * **monitorRect** - The full dimensions for the monitor. <br/>
         * **availableRect** - The dimensions for the available space on the monitor (not including the Windows task bar). <br/>
         * **position** - A number that represents the position of the monitor. The primary monitor is zero. <br/>
         * **whichMonitor** - Contains the string "primary" if it is the primary monitor. <br/>
         *
         * The dimensions are supplemented with the following additional members:
         *
         * **width** - The width calculated as right - left. <br/>
         * **height** - The height calculated as bottom - top. <br/>
         *
         * ```javascript
         * // Get the info for the monitor that the calling app is on
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo();
         * if(!err){
         *   console.log(data);
         * // Example results:
         * // {
         * //	availableRect: {width, height, bottom, left, ...},
         * //   deviceId: "123456",
         * //   deviceScaleFactor: 2,
         * //   displayDeviceActive: true,
         * //   monitor: {dipRect, scaledRect},
         * //   monitorRect: {width, height, bottom, left, right, ...}
         * //   name: "device0",
         * //   position: 0,
         * //   taskbar: {top, left, right, bottom, width, ...}
         * //   whichMonitor: "primary"
         * // }
         * }
         *
         * // Get monitor info for a given window
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({
         *   windowIdentifier: {
         *     windowName: "ABC-uuid"
         *   }
         * });
         * if(!err){
         *   console.log(`App ABC-uuid is currently on the monitor with index ${data.position}`);
         * }
         *
         * // Get the dimensions of the first non-primary monitor
         * const {err, data} = await FSBL.Clients.AppsClient.getMonitorInfo({monitor: 1});
         * if(!err){
         *   console.log("Available dimensions for monitor[1]: ", data.monitorRect);
         *   console.log("Available dimensions, minus claimed space, for monitor[1]: ", data.availableRect);
         * }
         * ```
         *
         * @param params
         * @param params.windowIdentifier The windowIdentifier to get the monitorInfo. If undefined, this points to the current window.
         * @param params.monitor If passed then a specific monitor is identified. Valid values include:
         *
         * <b>"mine"</b> - Place the window on the same monitor as the calling window.
         *
         * Integer value from 0-n (0 being the primary monitor).
         *
         * <b>"primary"</b> indicates the user's primary monitor.
         *
         * <b>"all"</b> - Put a copy of the component on each monitor.
         * @param cb Returns a monitorInfo object containing the monitorRect and availableRect.
         *
         * @returns A promise that resolves to a monitorInfo.
         */: string;
        componentType?: string;
    }, cb?: () => void) => Promise<void>;
    minimizeWindows: (params?: {
        windowList?: string[];
    }, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
    registerComponent: (params: {
        componentType: string;
        manifest: ComponentDescriptor;
    }, cb: StandardErrorCallback<string>) => StandardPromise<string>;
    removeUserDefinedComponent: (params: {
        name: string;
        url?: string;
    }, cb?: StandardErrorCallback<void>) => StandardPromise<void>;
    removeWindowsFromGroup: (params: {
        windowList?: string[] | WindowIdentifier[];
        groupName?: string;
    }, cb?: Function) => Promise<unknown>;
    showWindow: (windowLocator: WindowLocator, params: ShowWindowParams, cb?: StandardErrorCallback<SpawnResponse>) => StandardPromise<SpawnResponse>;
    spawn: (component: string, params: SpawnParams, cb?: StandardErrorCallback<SpawnResponse>) => Promise<{
        error?: StandardError;
        response?: SpawnResponse;
    }>;
    spawnTabCollection: ({ componentList, globalParams, }: {
        componentList: {
            appID: string;
            individualParams?: SpawnParams;
        }[];
        globalParams?: TabbedGlobalSpawnParams;
    }, cb?: StandardErrorCallback<SpawnTabCollectionResponse>) => StandardPromise<SpawnTabCollectionResponse>;
    toggleWindowOnClick: (element: HTMLElement, windowLocator: WindowLocator, params: ShowWindowParams) => void;
    unRegisterComponent: (params: {
        componentType: string;
    }, cb?: StandardErrorCallback<string>) => StandardPromise<string>;
    addApps: (apps: FDC3AppDefinition[], cb?: StandardErrorCallback) => StandardPromise<FDC3AppDefinition[]>;
    removeApps: (appIds: string[], cb?: StandardErrorCallback) => StandardPromise<string[]>;
    getApps: (appIds?: string[], cb?: StandardErrorCallback) => StandardPromise<FDC3AppDefinition[]>;
};
/**
 * @ignore
 */
export default AppsClient;
//# sourceMappingURL=appsClient.d.ts.map