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

package/platform/services/window/types.d.ts

@@ -0,0 +1,1194 @@
+import { PhysicalWindowState, Rectangle } from "../../../FEA";
+import { WINDOWSTATE } from "../../../common/constants";
+declare type FinsembleConfig = Record<string, any>;
+export declare type Bounds = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    bottom?: number;
+    right?: number;
+};
+export declare type PercentBounds = {
+    percentTop: string;
+    percentLeft: string;
+    percentWidth: string;
+    percentHeight: string;
+};
+/**
+ * Contains all the optional keys on the FinsembleWindowData
+ * type. See FinsembleWindowData for more info.
+ *
+ */
+export declare type OptionalFinsembleWindowData = {
+    /** DH 5/8/2019
+     * Confusingly, this is not the "official" component state.
+     * That's stored under an entirely different key. I'm not
+     * sure why or how this is here, but I definitely saw it
+     * at runtime.
+     */
+    componentState: Record<string, any>;
+    alphaMask: {
+        blue: number;
+        green: number;
+        red: number;
+    };
+    allowAutoArrange: boolean;
+    alwaysOnBottom: boolean;
+    alwaysOnTop: boolean;
+    applicationIcon: string;
+    autoShow: boolean;
+    backgroundColor: string;
+    backgroundThrottling: boolean;
+    bottom: number | string;
+    bounds: Bounds;
+    callstack: string;
+    center: boolean;
+    childWindowIdentifiers: [any];
+    contextMenu: boolean;
+    cornerRounding: {
+        height: number;
+        width: number;
+    };
+    customData: any;
+    defaultCentered: boolean;
+    defaultHeight: number;
+    defaultLeft: number;
+    defaultTop: number;
+    defaultWidth: number;
+    delay_connection: boolean;
+    disableIabSecureLogging: boolean;
+    draggable: boolean;
+    "enable-plugins": boolean;
+    enableLargerThanScreen: boolean;
+    exitOnClose: boolean;
+    experimental: {
+        disableInitialReload: boolean;
+        v2Api: boolean;
+    };
+    /** DH 6/14/2019
+     * We added this property because
+     * Electron/OF maintain their own
+     * record of which window has focus,
+     * creating the possibility for the
+     * OS and Electron/OF to think different
+     * windows have focus. Currently, we
+     * only keep this state on WebWindows.
+     * If we can figure out a different way
+     * to synchronize the OS and container,
+     * we may not need this state.
+     */
+    focused: boolean;
+    frame: boolean;
+    frameConnect: string;
+    hasLoaded: boolean;
+    height: number | string;
+    hideOnBlur: boolean;
+    hideOnClose: boolean;
+    hideOnce: boolean;
+    hideWhileChildrenVisible: boolean;
+    icon: string;
+    isEvergreen: boolean;
+    launchGroupComponentData: {
+        launchGroupId?: string;
+        launchGroupComponentUUID: string;
+        closeComponentsTogether: boolean;
+    };
+    launchExternal: "";
+    left: number | string;
+    loadErrorMessage: "";
+    maxHeight: number;
+    maxWidth: number;
+    maximizable: boolean;
+    monitorInfo: number;
+    minHeight: number;
+    minWidth: number;
+    minimizable: boolean;
+    monitorDimensions: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+        height: number;
+        width: number;
+    };
+    normalBounds?: Rectangle;
+    opacity: number;
+    options: any;
+    percentTop: string;
+    percentBottom: string;
+    percentLeft: string;
+    percentRight: string;
+    percentWidth: string;
+    percentHeight: string;
+    plugin: Record<string, any>[];
+    plugins: boolean;
+    preloadScripts: {
+        state?: "succeeded";
+        url: string;
+    }[];
+    resizable: boolean;
+    resize: boolean;
+    resizeRegion: {
+        bottomRightCorner: number;
+        sides: {
+            top: number;
+            bottom: number;
+            left: number;
+            right: number;
+        };
+        size: number;
+    };
+    right: number | string;
+    saveWindowState: boolean;
+    shadow: boolean;
+    show: boolean;
+    showTaskbarIcon: boolean;
+    skipTaskbar: boolean;
+    smallWindow: boolean;
+    state: string;
+    spawnedByWorkspaceService: boolean;
+    taskbarIcon: "";
+    taskbarIconGroup: string;
+    title: string;
+    top: number | string;
+    transparent: boolean;
+    type: string;
+    url: string;
+    uuid: string;
+    waitForPageLoad: boolean;
+    webPreferences: {
+        disableInitialReload: boolean;
+        nodeIntegration: boolean;
+        plugins: boolean;
+    };
+    webSecurity: boolean;
+    width: number | string;
+    windowIdentifier: {
+        name: string;
+        uuid: string;
+        windowName: string;
+        windowType: "WebWindow" | "NativeWindow" | "FinsembleNativeWindow";
+    };
+    windowState?: WINDOWSTATE;
+    windowType: "WebWindow" | "NativeWindow" | "FinsembleNativeWindow";
+    x: number;
+    y: number;
+};
+/**
+ * Represents all the state needed to recreate a Finsemble window.
+ *
+ * Pass to `Launcher.spawn` to spawn a new window with the given state.
+ *
+ * Once launched, the window saves its own state to storage, indexed by
+ * the workspace it belongs to. This state is also partially managed by
+ * the Workspace service.
+ */
+export declare type FinsembleWindowData = Partial<OptionalFinsembleWindowData> & {
+    componentType: string;
+    name: string;
+};
+export declare type IconUrl = {
+    imageType: "url" | "fonticon";
+    path: string;
+};
+export declare type IconInitials = {
+    imageType: "initials";
+    name: string;
+};
+export declare type IconDescriptor = (IconUrl | IconInitials) & {
+    category?: string;
+};
+export declare type AppIcons = {
+    taskbarIcon?: IconDescriptor;
+    toolbarIcon: IconDescriptor;
+    titleBarIcon: IconDescriptor;
+};
+export declare type WindowEventName = "blurred" | "bounds-change-start" | "startedMoving" | "bounds-changing" | "bounds-change-request" | "bounds-change-end" | "bounds-changed" | "system-bounds-changed" | "system-maximized" | "system-restored" | "crashed" | "system-closed" | "stoppedMoving" | "broughtToFront" | "clicked" | "close-requested" | "closed" | "alwaysOnTop" | "component-state-changed" | "close-complete" | "created" | "focused" | "hide-requested" | "hidden" | "maximize-requested" | "maximized" | "minimize-requested" | "minimized" | "parent-set" | "parent-unset" | "ready" | "restore-requested" | "restored" | "show-requested" | "shown" | "title-changed" | "wrap-state-changed";
+export declare type WrapState = "created" | "initializing" | "ready" | "reloading" | "closing" | "closed";
+export declare type WindowBounds = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    right?: number;
+    bottom?: number;
+};
+export declare type ShowWindowParams = any;
+declare type LaunchGroupComponentType = {
+    componentType: string;
+};
+declare type LaunchGroupComponentSpawnOptions = WindowBounds & {
+    position: PositionTypes;
+    addToWorkspace: boolean;
+    data: Record<string, any>;
+    monitor?: MonitorChoice;
+};
+export declare type LaunchGroupComponent = {
+    componentType: LaunchGroupComponentType;
+    spawnOptions: LaunchGroupComponentSpawnOptions;
+    launchGroupComponentData?: LaunchGroupComponentData;
+};
+export declare type LaunchGroupStackedWindow = {
+    components: LaunchGroupComponentType & {
+        spawnOptions: {
+            data: Record<string, any>;
+        };
+    }[];
+    spawnOptions: LaunchGroupComponentSpawnOptions;
+    launchGroupComponentData?: LaunchGroupComponentData;
+};
+export declare type LaunchGroupComponentData = {
+    launchGroupId?: string;
+    launchGroupComponentUUID: string;
+    closeComponentsTogether: boolean;
+};
+/**
+ * @deprecated - kept to ensure backwards compatibility, will be removed (or used by real composite components) in a future version
+ */
+export declare type CompositeComponentData = {
+    compositeComponentUUID: string;
+    closeComponentsTogether: boolean;
+};
+export declare type WindowLocator = {
+    /**
+     * The name of the physical HTML window, or a reference to a native window that was launched with Assimilation service
+     */
+    windowName: string;
+} | {
+    /**
+     * The type of component
+     */
+    componentType: string;
+    /**
+     * Optional uuid of a particular application process
+     */
+    uuid?: string;
+};
+/**
+ * An object that includes all the potential identifications for a window.
+ * For instance, one can try and obtain a reference for a window if some of these values are known.
+ */
+export declare type WindowIdentifier = {
+    /**
+     * The name of the physical HTML window, or a reference to a native window that was launched with Assimilation service
+     */
+    windowName: string;
+    /**
+     * The type of component
+     */
+    componentType?: string | null;
+    /**
+     * uuid is deprecated
+     */
+    uuid?: string;
+    windowType?: string;
+    waitForReady?: boolean;
+};
+export declare type CustomData = {
+    appConfig?: any;
+    monitorDimensions?: any;
+    window?: any;
+    manifest?: any;
+    spawnData?: any;
+    foreign?: any;
+    interop?: any;
+    component?: any;
+    isAnApp?: boolean;
+};
+export declare type WindowInterop = {
+    connectId?: ConnectId;
+    launchGroupId?: string;
+    parent?: WindowIdentifier;
+    grandParent?: WindowIdentifier;
+};
+export declare type ConnectId = string | undefined | null;
+/**
+ * Used to define the parameters for creating a Window.
+ */
+export declare type WindowDescriptor = {
+    name?: string;
+    uuid?: string;
+    monitorInfo?: any;
+    defaultLeft?: number;
+    defaultTop?: number;
+    defaultBottom?: number;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    defaultRight?: number;
+    /** The name of the component in this window. E.g "Welcome Component", etc. */
+    componentType?: string;
+    customData?: {
+        appConfig?: any;
+        monitorDimensions?: any;
+        window?: any;
+        manifest?: any;
+        spawnData?: any;
+        foreign?: any;
+        interop?: any;
+        component?: any;
+        isAnApp?: boolean;
+    };
+    claimMonitorSpace?: boolean;
+    canGroup?: boolean;
+    url?: string;
+    path?: string;
+    manifest?: {};
+    resizable?: boolean;
+    /** Process affinity setting that allows render threads for web windows (served from the same 'site') to be grouped together to save memory. Group render process together thoughtfully by setting the same string value or disable rendering process grouping by setting false. */
+    affinity?: string | boolean;
+    alwaysOnTop?: boolean;
+    autoShow?: boolean;
+    alwaysOnTopLevel?: string | null;
+    showTaskbarIcon?: boolean;
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    opacity?: number;
+    x?: number;
+    y?: number;
+    bounds?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    securityPolicy?: string;
+    backgroundColor?: string;
+    transparent?: boolean;
+    permissions?: {
+        System?: {};
+        Window?: {};
+        Application?: {};
+    };
+    execJSWhitelist?: Array<string>;
+    preload?: Array<any>;
+    preloadScripts?: Array<any>;
+    windowType?: string;
+    windowTitleBarUrl?: string;
+    childWindowOptions?: {
+        window?: any;
+        component?: any;
+        foreign?: any;
+    };
+    launchGroupComponentData?: LaunchGroupComponentData;
+    hideTitleBar?: boolean;
+    external?: boolean;
+    icons?: AppIcons;
+    windowInterop?: WindowInterop;
+    allowAutoArrange?: boolean;
+};
+/** All the possible window types, including their aliases used in config. */
+export declare type WindowTypes = "WebWindow" | "NativeWindow" | "assimilation" | "assimilated" | "native" | "FinsembleNativeWindow" | "application" | "WebApplication" | "composite" | "launchGroup" | "Citrix";
+export declare type MonitorChoice = number | "mine" | "primary" | "next" | "previous" | "all";
+/**
+ * All the possible position types that can be used to define the spawn viewport
+ *
+ * **"available"** Positioned according to the coordinates available on the monitor itself, less space claimed by the operating system (such as the windows toolbar).
+ * For instance, `bottom:0` will place the new component with its bottom flush against the windows toolbar.
+ *
+ * **"monitor"** Positioned according to the absolute size of the monitor.
+ * For instance, `top:0` will place the component overlapping the toolbar.
+ *
+ * **"relative"** Positioned relative to the relativeWindow.
+ * For instance, `left:0;top:0` will join the top left corner of the new component with the top left corner of the relative window.
+ *
+ * **"virtual"** Positioned against coordinates on the virtual screen.
+ *  The virtual screen is the full viewing area of all monitors combined into a single theoretical monitor.
+ *
+ * **"absolute"** Positioned using native operating system coordinates. Only available with showWindow, not with spawn.
+ *
+ */
+export declare type PositionTypes = "available" | "monitor" | "relative" | "virtual" | "absolute";
+export declare type SpawnOptions = {
+    autoShow?: boolean;
+    backgroundThrottling?: boolean;
+    contextMenu?: boolean;
+    "Content-Security-Policy"?: string | string[];
+    permissions?: any;
+    securityPolicy?: "trusted" | "untrusted";
+    showTaskbarIcon?: boolean;
+    cornerRounding?: {
+        width?: number;
+        height?: number;
+    };
+    opacity?: number;
+    openLinksInExternalBrowser?: boolean;
+    resizable?: boolean;
+    alwaysOnTop?: boolean;
+    isEvergreen?: boolean;
+    windowSpawnTimeout?: number;
+    windowTitleBarUrl?: string;
+    customData?: Record<string, any>;
+    /**
+     * A pixel value representing the distance from the top edge of the viewport as defined by "position".
+     * You can also use the percentage value, which represents the percentage distance from the top edge of the viewport relative to the viewport's height.
+     *
+     * <b>"adjacent"</b> will snap to the right edge of the spawning or relative window.
+     *
+     * <b>"center"</b> will center the window
+     *
+     * If neither left nor right are provided, then the default will be to stagger the window based on the last spawned window.
+     *
+     */
+    left?: number | string;
+    /**
+     * A pixel value representing the distance from the right edge of the viewport as defined by "position".
+     * You can also use the percentage value, which represents the percentage distance from the right edge of the viewport relative to the viewport's width.
+     *
+     */
+    right?: number | string;
+    /**
+     * A pixel value representing the distance from the top edge of the viewport as defined by "position".
+     * You can also use the percentage value, which represents the percentage distance from the top edge of the viewport relative to the viewport's height.
+     *
+     */
+    top?: number | string;
+    /**
+     * A pixel value representing the distance from the bottom edge of the viewport as defined by "position".
+     * You can also use the percentage value, which represents the percentage distance from the bottom edge of the viewport relative to the viewport's height.
+     *
+     */
+    bottom?: number | string;
+    /**
+     *  A pixel or percentage value.
+     */
+    width?: number | string;
+    /**
+     *  A pixel or percentage value.
+     */
+    height?: number | string;
+};
+/** The parameters passed to Launcher.Spawn.
+ *
+ * If properties are duplicated between the the app configuration those passed as
+ * parameters to `spawn`, parameters passed to `spawn` generally take precedence.
+ */
+export declare type SpawnParams = {
+    /**
+     * Adds the spawned app to a tab collection.
+     * If you supply a tabCollectionId string, Finsemble adds the app to the specified tab collection.
+     * If you supply a boolean, Finsemble attempts to tab with the calling window or the supplied relativeWindow argument.
+     */
+    addToTabCollection?: string | boolean;
+    /**
+     * Defaults to false. Whether to add the new component to the workspace.
+     * The addToWorkspace config value set at the component level overwrites this value.
+     */
+    addToWorkspace?: boolean;
+    /**
+     * Used when windowType is "native" or "assimilation". Specifies the alias of a bundled asset.
+     */
+    alias?: string;
+    /**
+     *  Process affinity setting that allows render threads for web windows (served from the same 'site') to be grouped together to save memory. Group render process together thoughtfully by setting the same string value or disable rendering process grouping by setting false.
+     */
+    affinity?: string | boolean;
+    /**
+     * Used when windowType is "native" or "assimilation". Specifies the arguments to be sent to the application. This is used in conjunction with path.
+     * Arguments should be separated by spaces: `--arg1 foo --arg2 bar` except when `params.argumentsAsQueryString` is true, in which case set this parameter to be single string in URI format: `arg=1&arg=2`"
+     */
+    arguments?: any;
+    /**
+     * For native applications launched by URI: 1) the string is passed as the "arguments" parameter if appended as a query string; and 2) the automatically generated arguments described in "path" are appended to the query string
+     */
+    argumentsAsQueryString?: boolean;
+    /**
+     * Whether the component can group with other windows.
+     */
+    canGroup?: boolean;
+    /**
+     *  For use with permanent toolbars.
+     * The available space for other components will be reduced by the amount of space covered by the newly spawned component.
+     * Users will be prevented from moving windows to a position that covers the claimed space.
+     */
+    claimMonitorSpace?: boolean;
+    /**
+     * Type of component to spawn.
+     */
+    component?: any;
+    /**
+     * Populate the initial component state on spawn.
+     */
+    componentState?: Record<string, any>;
+    /**
+     * @deprecated Please use groupOnSpawn instead.
+     * If true, will automatically group the window with the "relative" window (grouping to the parent window unless specified in params.relativeWindow).
+     * Note that you must also position the window in a valid position for grouping, for example, by setting the "left" or "top" parameters to "adjacent".
+     */
+    dockOnSpawn?: boolean;
+    /**
+     * An array of parts of the monitor that the component can dock to. Valid values are `top` and `bottom`.
+     */
+    dockable?: ["top", "bottom"] | ["bottom", "top"] | ["top"] | ["bottom"];
+    /**
+     * Which part of the monitor that the component will dock to on spawn. Valid options are `top` and `bottom`. Only valid if combined with the `dockable` property.
+     */
+    docked?: "top" | "bottom";
+    /**
+     * Currently, components can only dock to the full width of the monitor. This parameter determines what height the component will be when docked to a monitor.
+     */
+    dockedHeight?: number;
+    /**
+     * Indicates that this window is ephemeral.
+     * An ephemeral window is a dialog, menu, or other window that is temporarily displayed but usually hidden.
+     * Ephemeral windows automatically have the following settings assigned: resizable: false, showTaskbarIcon: false, alwaysOnTop: true.
+     * **Note**: Use `options:{autoShow: false}` to prevent an ephemeral widow from showing automatically.
+     *
+     */
+    ephemeral?: boolean;
+    /**
+     * If true, will attempt to make the window have no edges outside the monitor boundary.
+     */
+    forceOntoMonitor?: boolean | string;
+    /**
+     * Optional group name. Adds windows to a group (unrelated to docking or linking) that is used for window management functions. If the group does not exist it will be created.
+     */
+    groupName?: string;
+    /**
+     * Groups the window to the `relativeWindow` on spawn. Note that you must also position the window in a valid position for grouping, for example, by setting the "left" or "top" parameters to "adjacent".
+     */
+    groupOnSpawn?: boolean;
+    /**
+     * Which monitor to place the new window.
+     *
+     * <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 all monitors.
+     *
+     */
+    monitor?: MonitorChoice;
+    /**
+     * Name to give the component. If not provided, a random one will be generated.
+     */
+    name?: string;
+    /**
+     * @deprecated Please use windowType instead. Optional native application to launch with Assimilation service. Overrides what is passed in "component".
+     */
+    native?: boolean;
+    /**
+     * Properties to merge with the default windowDescriptor.
+     * Any value set here will be sent directly to the <code>WebWindow</code>, and will override the effect of relevant parameters to spawn(). By default, all Finsemble windows are frameless.
+     * FEA Permissions and window properties (such as always on top) are provided here.
+     */
+    options?: SpawnOptions & {
+        newStack?: boolean;
+        transparent?: any;
+        cachedBounds?: any;
+        windowState?: any;
+        preloadScripts?: any;
+        /**
+         * Name to give the component. Window name from the workspace service will be passed here.
+         */
+        name?: string;
+        minWidth?: number;
+        execJSWhitelist?: any;
+    };
+    /**
+     * Used when windowType is "native" or "assimilation". Specifies the path to the application. The path can be:
+     * The name of an exe that is on the system path (e.g., <i>notepad.exe</i>).
+     * The full path to an executable on the user's machine (e.g., <i>C:\Program Files\app.exe</i>).
+     * A system installed URI (e.g., <i>myuri://advancedapplauncher</i>).
+     *
+     * When windowType is "native" then additional arguments will be automatically appended to the path or the URI. These arguments can be captured by the native application
+     * in order to tie it to Finsemble's window tracking. When building an application with finsemble.dll, this is handled automatically. Those arguments are:
+     *
+     * **uuid** - A generated UUID that uniquely identifies this window.
+     *
+     * **left** - The x coordinate of the new window
+     *
+     * **top** - The y coordinate of the new window
+     *
+     * **width** - The width of the new window
+     *
+     * **height** - The height of the new window
+     *
+     * **finsembleWindowName** - The name of the window in the Finsemble config
+     *
+     * **componentType** - The component type in the Finsemble config
+     *
+     * A common troublesome problem is when a native application needs to be launched from an intermediary application (such as a launcher or batch script). That intermediary
+     * application can pass these parameters which will allow the final application to connect back to Finsemble.
+     */
+    path?: string;
+    /**
+     * Defines a "viewport" for the spawn, with one of the Position Types:
+     *
+     *
+     * <b>available</b> - Positioned according to the coordinates available on the monitor itself, less space claimed by the operating system (such as the windows toolbar).
+     * For instance, `bottom:0` will place the new component with its bottom flush against the windows toolbar.
+     *
+     * **monitor** - Positioned according to the absolute size of the monitor.
+     * For instance, `top:0` will place the component overlapping the toolbar.
+     *
+     * **relative** - Positioned relative to the relativeWindow.
+     * For instance, `left:0;top:0` will join the top left corner of the new component with the top left corner of the relative window.
+     *
+     * **virtual** - Deprecated. Positioned against coordinates on the virtual screen.
+     *  The virtual screen is the full viewing area of all monitors combined into a single theoretical monitor.
+     *
+     * **absolute** - Positioned using native operating system coordinates. Only available with showWindow, not with spawn.
+     */
+    position?: PositionTypes;
+    /**
+     * Sets environment variables for a spawned native application. Create a map (JSON) object of names to values. This is only available when running Assimilation.
+     */
+    env?: any;
+    /**
+     * The window to use when calculating any relative launches.
+     * If not set then the window from which spawn() was called.
+     */
+    relativeWindow?: WindowIdentifier;
+    /**
+     * Optional url to launch. Overrides what is passed in "component".
+     */
+    url?: string;
+    /**
+     * Optional. Describes which type of component to spawn.
+     *
+     * <b>WebWindow</b> - A normal HTML window.
+     *
+     * <b>assimilation</b> - A window that is managed by the Finsemble assimilation process (usually a native window without source code access). Requires "path" to be specified, which may be the name of an executable on the system path, a system file path or system installed URI.
+     *
+     * <b>native</b> - A native window that has implemented finsemble.dll. Requires "path" to be specified.
+     *
+     * <b>application</b> - A standalone application that will be launched in its own browser process (giving it dedicated CPU and memory).
+     * This can also point to a standalone web application (such as from a third party).
+     *
+     * <b>composite</b> - DEPRECATED - Use launchGroup.
+     *
+     * <b>launchGroup</b> - A component composed of other components, usually group together. See `toSpawn` property.
+     */
+    windowType?: WindowTypes;
+    /**
+     * Component instances are often referred to in Finsemble API calls via a <a href="/docs/productivity/componentTypesAndWindowNames#windowidentifier">windowIdentifier</a>. A windowIdentifier is an object with both windowName and componentType properties.
+     * @private
+     */
+    windowIdentifier?: WindowIdentifier;
+    /**
+     * If true then the new window will act as a slave to the relativeWindow (or the launching window if relativeWindow is not specified).
+     * Slave windows will automatically close when their parent windows close.
+     */
+    slave?: boolean;
+    /** *
+     * @private
+     */
+    spawnedByWorkspaceService?: boolean;
+    /**
+     * Number of pixels to stagger (default when neither left, right, top or bottom are set).
+     */
+    staggerPixels?: number;
+    /**
+     * Where the spawn request is coming from.
+     * @private
+     */
+    launchingWindow?: WindowIdentifier;
+    /**
+     * Optional data to pass to the opening window.
+     * If set, then the spawned window can use <a href="/docs/reference/typedocs/modules/WindowClient#getSpawnData">WindowClient#getSpawnData</a> to retrieve the data.
+     */
+    data?: any;
+    /**
+     * A pixel value representing the distance from the left edge of the viewport as defined by "position". Must be numeric for absolute positions.
+     * You can also use the percentage value, which represents the percentage distance from the left edge of the viewport relative to the viewport's width.
+     *
+     * <b>"adjacent"</b> will snap to the right edge of the spawning or relative window.
+     *
+     * <b>"center"</b> will center the window
+     *
+     * If neither left nor right are provided, then the default will be to stagger the window based on the last spawned window.
+     *
+     */
+    left?: number | string;
+    /**
+     * A pixel value representing the distance from the right edge of the viewport as defined by "position".
+     * For non-absolute positions, you can also use the percentage value, which represents the percentage distance from the right edge of the viewport relative to the viewport's width.
+     *
+     */
+    right?: number | string;
+    /**
+     * A pixel value representing the distance from the top edge of the viewport as defined by "position".
+     * For non-absolute positions, you can also use the percentage value, which represents the percentage distance from the top edge of the viewport relative to the viewport's height.
+     *
+     */
+    top?: number | string;
+    /**
+     * A pixel value representing the distance from the bottom edge of the viewport as defined by "position".
+     * For non-absolute positions, you can also use the percentage value, which represents the percentage distance from the bottom edge of the viewport relative to the viewport's height.
+     *
+     */
+    bottom?: number | string;
+    /**
+     *  A pixel or percentage value.
+     */
+    width?: number | string;
+    /**
+     *  A pixel or percentage value.
+     */
+    height?: number | string;
+    /**
+     * Minimum width window can be resized to.
+     */
+    minWidth?: number;
+    /**
+     * Minimum height window can be resized to.
+     */
+    minHeight?: number;
+    /**
+     * Maximum height window can be resized to.
+     */
+    maxHeight?: number;
+    /**
+     * Maximum width window can be resized to.
+     */
+    maxWidth?: number;
+    /**
+     * If true, then visibility of window will not be changed. In other words, a hidden window will not be made visible.
+     */
+    setBoundsOnly?: boolean;
+    /**
+     * Optional - sets a tab title for the window.
+     */
+    tabTitle?: string;
+    /**
+     * An array of objects defining the components to spawn. Each entry may either represent
+     * a single component in the form `{componentType, spawnOptions}` or a tabbed window of components in the form
+     * `{components, spawnOptions}`, where `components` is an array of single component definitions (again in the form
+     * `{componentType, spawnOptions}`).
+     * Most arguments that are normally passed to `LauncherClient.spawn` are supported, although positioning will be
+     * interpreted as relative to the group's coordinates and dimensions for single components and ignored for tabbed
+     * components (as these use the position specified in the group's spawnOptions).
+     * **Note** - This param will only be taken into account if the `windowType` param is 'composite' OR 'launchGroup'.
+     */
+    toSpawn?: [object];
+    /**
+     * Defaults to false. Whether to close all components within a launchGroup component at the same time.
+     */
+    closeComponentsTogether?: boolean;
+    launchGroupComponentData?: LaunchGroupComponentData;
+    /**
+     * @deprecated
+     */
+    compositeComponentData?: CompositeComponentData;
+    windowTitleBarUrl?: string;
+    frame?: boolean;
+    windowInterop?: WindowInterop;
+    connectId?: string;
+};
+interface BootParams {
+    stage?: "microkernel" | "kernel" | "pre-authentication" | "authentication" | "preuser" | "earlyuser" | "user";
+    stopOnFailure?: boolean;
+    autoStart?: boolean;
+    customFailureMessage?: string;
+    timeout?: number;
+    dependencies?: string[];
+    checkpoints?: any;
+}
+interface Foreign {
+    agentLabel?: string;
+    clients?: any;
+    services?: {
+        windowService?: {
+            global?: boolean;
+            allowSnapping?: boolean;
+            isArrangable?: boolean;
+            allowGrouping?: boolean;
+            allowAutoArrange?: boolean;
+            allowTabbing?: boolean;
+            allowTiling?: boolean;
+            allowMinimize?: boolean;
+            allowMaximize?: boolean;
+            shouldRegister?: boolean;
+            manageWindowMovement?: boolean;
+            [k: string]: any;
+        };
+        workspaceService?: {
+            persistURL?: boolean;
+            persistPath?: boolean;
+            [k: string]: any;
+        };
+        dockingService?: {
+            canGroup?: boolean;
+            additionalProperties?: false;
+            [k: string]: any;
+        };
+        additionalProperties?: false;
+        [k: string]: any;
+    };
+    components?: {
+        "App Launcher"?: {
+            launchableByUser?: boolean;
+            [k: string]: any;
+        };
+        "Window Manager"?: {
+            launchableByUser?: boolean;
+            [k: string]: any;
+            titleBarHeight?: number;
+            disableBrowserView?: boolean;
+            titlebarType?: string;
+        };
+        Toolbar?: {
+            iconURL?: string;
+            iconClass?: string;
+            [k: string]: any;
+        };
+        [k: string]: any;
+    };
+    custom?: Record<string, any>;
+    additionalProperties?: false;
+    [k: string]: any;
+}
+export interface ComponentConfig {
+    componentType?: string;
+    bootParams?: BootParams;
+    signatureKey?: {
+        alg?: string;
+        ext?: boolean;
+        key_ops?: string[];
+        kty?: string;
+        n?: string;
+        e?: string;
+        [k: string]: any;
+    };
+    isAnApp?: boolean;
+    appConfig?: Record<string, any>;
+    interop?: {
+        useLinker?: boolean;
+        autoConnect?: boolean;
+        selectConnect?: {
+            authorize?: {
+                name?: string;
+                [k: string]: NonNullable<any>;
+            }[];
+            to?: {
+                name?: string;
+                [k: string]: NonNullable<any>;
+            }[];
+            from?: {
+                name?: string;
+                [k: string]: NonNullable<any>;
+            }[];
+            cc?: string;
+            contextType?: string;
+            fwd?: string;
+            [k: string]: NonNullable<any>;
+        }[];
+        [k: string]: NonNullable<any>;
+    };
+    window?: Record<string, any>;
+    components?: Record<string, ComponentConfig>;
+    component?: {
+        type?: string;
+        category?: string;
+        mode?: string;
+        advertiseReceivers?: string[] | string;
+        spawnOnStartup?: boolean;
+        spawnOnAllMonitors?: boolean;
+        canMinimize?: boolean;
+        canMaximize?: boolean;
+        useAppCatalog?: boolean;
+        singleton?: boolean;
+        showDevConsoleOnVisible?: boolean;
+        allowQuickComponent?: string;
+        neededClients?: string[];
+        displayName?: string;
+        centralLoggerNamePrefix?: string;
+        preload?: boolean | string | string[];
+        inject?: boolean | string;
+        spawnOnHotkey?: string[];
+        custom?: Record<string, any>;
+        isUnknownComponent?: boolean;
+    };
+    foreign?: Foreign;
+    childWindowOptions?: ComponentConfig;
+    custom?: Record<string, any>;
+    value?: any;
+    windowTitleBarUrl?: string;
+    params?: Record<string, any>;
+    spawnOptions?: Record<string, any>;
+    launchGroupComponentData?: LaunchGroupComponentData;
+}
+export declare type LaunchGroupTabbedComponent = {
+    componentType: string;
+    spawnOptions: Record<string, any>;
+};
+export declare type LaunchGroupTabbedComponents = {
+    components: LaunchGroupTabbedComponent[];
+    launchGroupComponentData: LaunchGroupComponentData;
+    spawnOptions: SpawnOptions;
+};
+export declare type ComponentMutateParams = {
+    /** Field to save. */
+    field?: string;
+    /** Fields to save. */
+    fields?: {
+        field: string;
+    }[];
+    /** Key to store the data under. */
+    key?: string;
+    /** Whether the data is componentState or windowData. Defaults to "windowData" */
+    stateVar?: "componentState" | "windowData";
+    /** Topic that the data is stored under. */
+    topic?: string;
+    /** Value to save. */
+    value?: any;
+};
+/**
+ * A structure representing a collection of tabs. Tabs are associated with (but do not fully represent) a window. The tab
+ * is primarily responsible for the title of the associated window. A tab collection tracks any number of tabs, the tab order
+ * (position), title and the windowName (which is the actual ID of the window). As well, the currently promoted (active) tab
+ * is specified here.
+ *
+ * This object is passed via remote-redux by way of TitleBarData. Do not overload it or updated it too frequently.
+ */
+export declare type TabCollection = {
+    tabCollectionId: string;
+    /**
+     * The tabs. Ordering is implicit in the array.
+     */
+    tabs: string[];
+    /**
+     * The currently active tab within the collection.
+     */
+    promotedWindowName: string;
+    /**
+     * The number of pixels currently scrolled within the titlebar.
+     */
+    scroll: number;
+};
+export declare type BumpConfig = {
+    bumpBy: string;
+    fixed: string;
+    absolute: string;
+    monitorFixedAdditions: boolean;
+    adjustContentHeights: boolean;
+    bumpFixedElements: boolean;
+    hackScrollbar: boolean;
+};
+/**
+ * Contains all the information necessary to render the WindowTitleBar. This is passed over remote-redux, so this object
+ * should not contain anything extraneous to what the WindowTitleBar's UI needs to know about.
+ */
+export declare type TitleBarData = {
+    maximized: boolean;
+    alwaysOnTop: boolean;
+    title: string | null;
+    editable: boolean;
+    groupable: boolean;
+    isGrouped: boolean;
+    tabCollectionId: string | null;
+    enableTabbing: boolean;
+    showMaximizeButton: boolean;
+    showMinimizeButton: boolean;
+    showAlwaysOnTopButton: boolean;
+    showCloneButton: boolean;
+    showCloseButton: boolean;
+    showShareButton: boolean;
+    bumpConfig: BumpConfig | null;
+    icon: IconDescriptor | null;
+};
+export declare type WindowGroup = {
+    windowNames: string[];
+    topRightWindow: string;
+    topRightWindows: string[];
+    isGrouped: boolean;
+    ungroupedAlwaysOnTopState?: Record<string, Boolean>;
+};
+export declare type SafetyTimeout = ReturnType<typeof setTimeout> | null;
+export declare type WindowDescriptorScrubbed = Omit<WindowDescriptor, "childWindowOptions" | "manifest" | "permissions">;
+export declare type WindowServiceStore = {
+    windowTitleBar: {
+        windows: Record<string, TitleBarData>;
+        dragging: null | {
+            windowNameBeingDragged: string;
+            inWindowName: string | null;
+            temporaryPosition: number | null;
+            tabWidth: number | null;
+        };
+        tabCollections: Record<string, TabCollection>;
+        useDOMBasedMovement: boolean;
+    };
+    ux: {
+        scrimWindowName: string | null;
+        resolverWindowName: string | null;
+        highlightedWindowName: string | null;
+        scrimSafetyTimeout: SafetyTimeout;
+    };
+    main: {
+        windows: Record<string, {
+            titles: {
+                titleFromDocument?: string | null;
+                titleFromAPI?: string | null;
+                titleFromConfig?: string | null;
+                titleFromUser?: string | null;
+                titleFromAppD?: string | null;
+            };
+            physicalWindowState: PhysicalWindowState;
+        }>;
+        /**
+         * We use a hybrid approach to maximization. Windows are always maximized natively (e.g. using BrowserWindow.maximize()). This includes single
+         * windows and also the promoted (visible) tab in a collection. The hidden windows however are given “emulated maximization”. While hidden, hey
+         * are resized to the same size as the, truly maximized, promoted window (this occurs because a resized event always accompanies a maximize and thus the
+         * hidden windows follow that resizing).
+         *
+         * Windows' “normalBounds” (the position and dimensions before maximizing) are saved in this section of the store. The `emulated`
+         * flag indicates whether the window was truly maximized or merely emulated.
+         *
+         * A user unmaximize action then depends on whether the window being unmaximized is truly OS maximized or just emulated.
+         * Either way, a reducer ensures that all of the hidden tabs are either naturally unmaximized (by calling "restore") or
+         * merely resized away from their emulated maximized state.
+         *
+         * Most of this logic is in the main module when processing `resize`, `resized`, and `maximize` events. The actions.maximize reducer in
+         * the windowTitleBar module and addTabToCollection also work to keep the emulation accurate.
+         *
+         * This is all done pretty much to eliminate the ugly flashing effect that comes from maximizing a hidden tab during promotion but
+         * also helps with restoring maximized collections from workspaces and dragging windows into maximized collections. It also works
+         * around a nuance where Electron considers a window to be maximized even if it is merely resized to the full size of the monitor, and
+         * a fallout idiosyncrasy that normalBounds can be set to the full monitor size when a maximized window changes visibility.
+         */
+        maximization: Record<string, {
+            normalBounds: Rectangle;
+            maximizedBounds: Rectangle;
+            emulated: boolean;
+        }>;
+        launchData: Record<string, {
+            windowDescriptor: WindowDescriptorScrubbed;
+            workspaceWindow: boolean;
+            userDefinedTitle?: string;
+            windowDotOpen: boolean;
+        }>;
+        groups: Record<string, WindowGroup>;
+        workspaceClosings: string[];
+        dockingOperation: {
+            type: "swapping" | "detaching" | "tiling" | null;
+        };
+    };
+    finsembleConfig: FinsembleConfig;
+    api: {};
+    root: {
+        isVisible: boolean;
+        quashedActions: string[];
+        testing: {
+            unitTestingEnabled: boolean;
+            error: string;
+        };
+    };
+    "@@cmds"?: any[];
+};
+export declare type WindowServiceRootStore = WindowServiceStore["root"];
+export declare type WindowTitleBarStore = WindowServiceStore["windowTitleBar"];
+export declare type WindowServiceMainStore = WindowServiceStore["main"];
+export declare type WindowServiceUXStore = WindowServiceStore["ux"];
+export declare type DraggingStatus = NonNullable<WindowTitleBarStore["dragging"]>;
+export declare type DockingOperation = WindowServiceStore["main"]["dockingOperation"];
+export declare type ActionWindowSetTest = {
+    test: string;
+};
+export declare type ReduxPayloadEmpty = {};
+export declare type ReduxPayloadWindowName = {
+    targetWindowName: string;
+};
+export declare type ReduxPayloadWindowNames = {
+    windowNames: string[];
+};
+export declare type ReduxPayloadTabPosition = {
+    targetWindowName: string;
+    position: number;
+};
+/**
+ * Remove a window from a tab collection and place on desktop
+ * Note: what about tiling?
+ */
+export declare type ReduxPayloadSetLocation = {
+    targetWindowName: string;
+    monitor: number;
+    x: number;
+    y: number;
+};
+export declare type ReduxPayloadAddLaunchData = {
+    windowDescriptor: WindowDescriptor;
+    tabTitleFromSpawn?: string;
+    workspaceWindow: boolean;
+    finsembleConfig: FinsembleConfig;
+    windowDotOpen: boolean;
+};
+export declare type ReduxPayloadWindowTitle = {
+    title: string | null;
+};
+/**
+ * Generic action payload that can be used to set any binary state
+ */
+export declare type ReduxPayloadToggleState = {
+    toggleState: boolean;
+};
+/**
+ * Generic action payload that can be used to set any binary state but
+ * targeting a specific window
+ */
+export declare type ReduxPayloadToggleStateWithTarget = {
+    toggleState: boolean;
+    targetWindowName: string;
+};
+export declare type ReduxPayloadScrollTabCollection = {
+    scroll: number;
+};
+/**
+ * Establish an entire collection, such as when restoring from workspace or spawning a collection
+ */
+export declare type ReduxPayloadCollection = {
+    windowNames: string[];
+    tabCollectionId?: string;
+    promotedWindowName?: string;
+};
+export declare type ReduxPayloadAddToCollection = {
+    windowNames: string[];
+    tabCollectionId: string;
+    position?: number;
+    promotedWindowName?: string;
+};
+export declare type ReduxPayloadWorkspaceLoad = {
+    tabCollections: TabCollection[];
+};
+export declare type ReduxPayloadEmulatedMaximization = {
+    targetWindow: string;
+    normalBounds: Rectangle;
+    maximizedBounds: Rectangle;
+};
+/**
+ * The docking system has a single choke point, publishGroupUpdate, where groups are reassessed and published.
+ * This payload includes all known groups mapped to their array of window names and the top right window, which
+ * can be used to determine whether to display a minimize button on that window.
+ */
+export declare type ReduxPayloadGroups = Record<string, WindowGroup>;
+export declare type ReduxPayloadWindowFilter = {
+    monitor?: string;
+    windowList?: string[];
+    windowName?: string;
+};
+export declare type TabbedGlobalSpawnParams = {
+    left?: number | string;
+    right?: number | string;
+    top?: number | string;
+    bottom?: number | string;
+    width?: number | string;
+    height?: number | string;
+    position?: PositionTypes;
+    launchingWindow?: WindowIdentifier;
+    promotedTabPosition?: number;
+    addToWorkspace?: boolean;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map