@interopio/desktop 6.15.0 → 6.16.0

package/desktop.d.ts

@@ -98,6 +98,12 @@ export declare namespace IOConnectDesktop {
          */
         appManager?: boolean | IOConnectDesktop.AppManager.Mode;
 
+        /**
+         * Initializes or disables the Apps API.
+         * @default false
+         */
+        apps?: boolean;
+
         /**
          * Initializes or disables the Layouts API. You can also specify mode and configuration with which that Layouts API will be initialized.
          * @default "slim"
@@ -174,6 +180,16 @@ export declare namespace IOConnectDesktop {
          */
         appManager: IOConnectDesktop.AppManager.API;
 
+        /**
+         * Apps API.
+         */
+        apps: IOConnectDesktop.Apps.API;
+
+        /**
+         * Platform API.
+         */
+        platform: IOConnectDesktop.Platform.API;
+
         /**
          * Layouts API.
          */
@@ -959,10 +975,13 @@ export declare namespace IOConnectDesktop {
      * - *Instance* - a running copy of an app. The App Management API provides facilities for starting/stopping app instances and tracking app-related events.
      *
      * The App Management API is accessible through the `io.appManager` object.
+     *
+     * @deprecated The AppManager API is deprecated. Use the new Apps API (`io.apps`) instead.
      */
     namespace AppManager {
         /**
          * App Management API.
+         * @deprecated Use the new Apps API (`io.apps`) instead. This API will be removed in a future version.
          */
         export interface API extends AppManager, Entitlements {
             /**
@@ -1510,7 +1529,7 @@ export declare namespace IOConnectDesktop {
             /**
              * Retrieves the starting context of the instance.
              */
-            getContext(): Promise<object>;
+            getContext(): Promise<Record<string, any>>;
 
             /**
              * Retrieves the window object corresponding to the app instance.
@@ -1651,8 +1670,6 @@ export declare namespace IOConnectDesktop {
             activityType?: string;
             /** If `true`, multiple instances of the app can be started. */
             allowMultiple?: boolean;
-            /** Whether to register the iodesktop object in the global window context. */
-            registerIoDesktop?: boolean;
         }
 
         /** @ignore */
@@ -1694,6 +1711,492 @@ export declare namespace IOConnectDesktop {
         }
     }
 
+    /**
+     * The App Management V2 API provides a modern, fully async way to manage **io.Connect Desktop** apps.
+     * It is accessible through the `io.apps` object.
+     */
+    namespace Apps {
+        /**
+         * App Management API.
+         */
+        export interface API {
+            /**
+             * Provides access to the current app instance and application definition.
+             * This is useful for getting information about the app currently running in the foreground.
+             */
+            readonly my: My;
+
+            /**
+             * App registry for managing app definitions and metadata.
+             */
+            readonly registry: AppRegistry;
+
+            /**
+             * Instance manager for controlling running app instances.
+             */
+            readonly instances: InstanceManager;
+        }
+
+        /**
+         * Provides access to the current app instance and application definition.
+         * This is useful for getting information about the app currently running in the foreground.
+         */
+        export interface My {
+            /**
+             * The current application instance.
+             */
+            readonly instance: ApplicationInstance;
+
+            /**
+             * My application name.
+             */
+            readonly appName: string;
+        }
+
+        /**
+         * App registry for managing app definitions and metadata.
+         */
+        export interface AppRegistry {
+            /**
+             * API for handling app definitions at runtime.
+             * The API methods operate only on in-memory app definitions.
+             */
+            readonly inMemory: InMemoryStore;
+
+            /**
+             * Retrieves an app definition by name.
+             * @param options Options for retrieving the app definition.
+             */
+            get(options: GetAppOptions): Promise<Application | null>;
+
+            /**
+             * Retrieves multiple app definitions with optional filtering and pagination.
+             * @param filter Optional filter criteria for apps.
+             * @param options Options for retrieving app definitions.
+             */
+            getMany(filter?: AppFilter): Promise<Application[]>;
+
+            /**
+             * Checks if an app exists and is available.
+             * @param name The name of the app to check.
+             */
+            has(name: string): Promise<boolean>;
+
+            /**
+             * Subscribes to app addition events.
+             * @param handler Handler for app addition events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onAdded(handler: AppEventHandler<AppAddedEvent>): Promise<UnsubscribeFunction>;
+
+            /**
+             * Subscribes to app removal events.
+             * @param handler Handler for app removal events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onRemoved(handler: AppEventHandler<AppRemovedEvent>): Promise<UnsubscribeFunction>;
+
+            /**
+             * Subscribes to app update events.
+             * @param handler Handler for app update events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onUpdated(handler: AppEventHandler<AppUpdatedEvent>): Promise<UnsubscribeFunction>;
+
+        }
+
+        /**
+         * Instance manager for controlling running app instances.
+         */
+        export interface InstanceManager {
+            /**
+             * Starts a new app instance.
+             * @param options Options for starting the app instance.
+             */
+            start(options: StartAppOptions): Promise<ApplicationInstance>;
+
+            /**
+             * Stops an app instance.
+             * @param options Options for stopping the app instance.
+             */
+            stop(options: StopInstanceOptions): Promise<void>;
+
+            /**
+             * Waits for an app instance to be ready.
+             * This method resolves when the app instance is fully initialized and ready to use.
+             * @param options Options for waiting for an app instance to be ready.
+             */
+            waitForReady(options: InstanceSelect): Promise<void>;
+
+            /**
+             * Retrieves an app instance by ID.
+             * @param options Options for selecting the instance.
+             */
+            get(options: InstanceSelect): Promise<ApplicationInstance | null>;
+
+            /**
+             * Retrieves all running app instances with optional filtering.
+             * @param filter Optional filter criteria for instances.
+             */
+            getMany(filter?: InstanceFilter): Promise<ApplicationInstance[]>;
+
+            /**
+             * Retrieves the state of an app instance.
+             * @param options Options for selecting the instance.
+             */
+            getState(options: InstanceSelect): Promise<InstanceState>;
+
+            /**
+             * Retrieves the context of an app instance.
+             * @param options Options for selecting the instance.
+             */
+            getContext(options: InstanceSelect): Promise<Record<string, any>>;
+
+            /**
+             * Restarts an app instance.
+             * @param options Options for restarting the instance.
+             */
+            restart(options: RestartInstanceOptions): Promise<ApplicationInstance>;
+
+            /**
+             * Subscribes to instance started events.
+             * @param handler Handler for instance started events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onStarted(handler: InstanceEventHandler<InstanceStartedEvent>): Promise<UnsubscribeFunction>;
+
+            /**
+             * Subscribes to instance stopped events.
+             * @param handler Handler for instance stopped events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onStopped(handler: InstanceEventHandler<InstanceStoppedEvent>): Promise<UnsubscribeFunction>;
+
+            /**
+             * Subscribes to instance state changed events.
+             * @param handler Handler for instance state changed events.
+             * @returns A promise that resolves to an unsubscribe function.
+             */
+            onStateChanged(handler: InstanceEventHandler<InstanceStateChangedEvent>): Promise<UnsubscribeFunction>;
+        }
+
+        /**
+         * API for handling app definitions at runtime.
+         * The API methods operate only on in-memory app definitions.
+         */
+        export interface InMemoryStore {
+            /**
+             * Imports the provided collection of app definitions.
+             * @param definitions A collection of app definition objects to be imported.
+             * @param mode Mode for importing app definitions. Use `"replace"` (default) to replace all existing in-memory app definitions.
+             * Use `"merge"` to update the existing ones and add new ones.
+             */
+            import(definitions: Definition[], mode?: "replace" | "merge"): Promise<ImportResult>;
+
+            /**
+             *
+             * Checks if an app definition exists in the in-memory store.
+             * @param name The name of the app definition to check.
+             */
+            has(name: string): Promise<boolean>;
+
+            /**
+             * Removes an app definition from the in-memory store.
+             * @param options Remove options.
+             */
+            remove(options: RemoveAppOptions): Promise<void>;
+
+            /**
+             * Removes all app definitions from the in-memory store.
+             * @param options Clear options.
+             */
+            clear(options?: ClearAppsOptions): Promise<void>;
+        }
+
+        // Event Types
+        export type AppAddedEvent = { app: ApplicationCore; };
+        export type AppRemovedEvent = { appName: string; };
+        export type AppUpdatedEvent = { app: ApplicationCore; changes: AppChangeSet };
+
+        export type InstanceStartedEvent = { instance: ApplicationInstance; };
+        export type InstanceStoppedEvent = { instance: ApplicationInstance; reason?: string; };
+        export type InstanceStateChangedEvent = { instance: ApplicationInstance; state: InstanceState }
+
+        // Event Handlers
+        export type AppEventHandler<T> = (event: T) => void;
+        export type InstanceEventHandler<T> = (event: T) => void;
+
+        export interface ApplicationCore {
+            readonly name: string;
+            readonly type: AppType;
+            readonly title?: string;
+            readonly version?: string;
+            readonly description?: string;
+            readonly icon?: string;
+            readonly iconURL?: string;
+            readonly keywords?: string[];
+            readonly autoStart?: boolean;
+            readonly allowMultiple?: boolean;
+            readonly isHidden?: boolean;
+            readonly isShell?: boolean;
+            readonly isInMemory?: boolean;
+        }
+
+        // Core Data Types
+        export interface Application extends ApplicationCore {
+            fdc3?: Record<string, any>;
+            customProperties?: Record<string, any>;
+            definition?: Definition;
+            instances?: ApplicationInstance[];
+        }
+
+        export interface ApplicationInstance {
+            id: string;
+            appName: string;
+            startedAt: Date;
+            startedBy: StartedByInfo;
+            interopInstance?: Promise<IOConnectDesktop.Interop.Instance>;
+            pid?: number;
+        }
+
+        // Filter Types
+        export interface AppFilter extends AppDataOptions {
+            readonly names?: string[];
+            readonly types?: AppType[];
+            readonly isHidden?: boolean;
+            readonly isFdc3Definition?: boolean;
+            readonly isInMemory?: boolean;
+            readonly keywords?: string[];
+            readonly customProperties?: Record<string, any>;
+        }
+
+        export interface InstanceFilter {
+            readonly ids?: string[];
+            readonly appNames?: string[];
+            readonly startedAfter?: Date;
+            readonly startedBefore?: Date;
+        }
+
+        // Options Types
+        export interface GetAppOptions extends AppSelect, AppDataOptions {
+        }
+
+        export interface AppSelect {
+            readonly name: string;
+        }
+
+        export interface AppDataOptions {
+            /**
+             * If true, the app definition will be included in the result.
+             * @default false
+             */
+            readonly includeDefinition?: boolean;
+            /**
+             * If true, the app instances will be included in the result.
+             * @default true
+             */
+            readonly includeInstances?: boolean;
+        }
+
+        export interface StartAppOptions {
+            readonly name: string;
+            /**
+             * Context to pass to the started instance.
+             * If not provided, the context from the app definition will be used.
+             * If the app definition does not have a context, an empty object will be used.
+             */
+            readonly context?: Record<string, any>;
+            /**
+             * If provided, this will override the app definition used to start the instance.
+             * TODO We have to decide how to handle this - we have so called startup args like ignoreSavedLayout, hidden, focus,
+             * TODO It is a mixture of top-level app properties and app-details-specific properties.
+             */
+            readonly definitionOverride?: Record<string, any>;
+            /**
+             * The timeout for the start operation in milliseconds.
+             * @default 120000
+             */
+            readonly timeout?: number;
+            /**
+             * If true, the app will attempt to reuse an existing instance if available.
+             * @default false
+             */
+            readonly reuseInstance?: boolean;
+        }
+
+        export interface StopInstanceOptions {
+            /**
+             * The ID of the instance to stop.
+             */
+            readonly id: string;
+            /**
+             * If true, the instance will be forcefully stopped without waiting for it to gracefully shut down.
+             * @default false
+             */
+            readonly force?: boolean;
+            /**
+             * The timeout for the stop operation in milliseconds.
+             * @default 30000
+             */
+            readonly timeout?: number;
+            /**
+             * Optional reason for stopping the instance.
+             */
+            readonly reason?: string;
+        }
+
+        export interface RestartInstanceOptions {
+            /**
+             * The ID of the instance to restart.
+             */
+            readonly id: string;
+            /**
+             * Context to pass to the restarted instance.
+             * If "preserve", the context from the original instance is reused.
+             * If "clear", the context is reset to an empty object.
+             * If not provided, the context is preserved by default.
+             * @default "preserve"
+             */
+            readonly context?: Record<string, any> | "preserve" | "clear";
+            /**
+             * If true, the original app definition is used for the restarted instance.
+             * @default false
+             */
+            readonly useOriginalDefinition?: boolean;
+            /**
+             * The timeout for the restart operation.
+             * @default 120000
+             */
+            readonly timeout?: number;
+        }
+
+        export interface ImportOptions {
+            readonly mode?: "replace" | "merge";
+            readonly validateOnly?: boolean;
+            readonly skipInvalid?: boolean;
+        }
+
+        export interface ExportOptions {
+            readonly includeConfiguration?: boolean;
+            readonly includeMetadata?: boolean;
+        }
+
+        export interface RemoveAppOptions {
+            readonly name: string;
+            readonly stopInstances?: boolean;
+        }
+
+        export interface ClearAppsOptions {
+            readonly stopAllInstances?: boolean;
+            readonly preserveSystemApps?: boolean;
+        }
+
+        export interface InstanceSelect {
+            readonly id: string;
+        }
+
+        // Enum Types
+        export type AppType = ApplicationConfig["type"];
+        export type InstanceState = "started" | "ready" | "stopped" | "failed";
+
+        export interface AppChangeSet {
+            readonly [key: string]: any;
+        }
+
+        export type Definition = ApplicationConfig;
+
+        export interface ImportResult {
+            readonly imported: string[];
+            readonly updated: string[];
+            readonly failed: {
+                readonly name: string;
+                readonly error: string;
+                readonly details?: Record<string, any>;
+            }[];
+            readonly warnings: {
+                readonly name: string;
+                readonly warning: string;
+                readonly details?: Record<string, any>;
+            }[];
+        }
+
+        // Re-export common types from legacy namespace for compatibility
+        export import StartedByInfo = IOConnectDesktop.AppManager.StartedByInfo;
+    }
+
+    /**
+     * @intro
+     * **Platform API** provides system-level operations like restart, shutdown, and shutdown event handling.
+     * It offers a clean interface for managing platform lifecycle events.
+     *
+     * The Platform API is accessible through the `io.platform` object.
+     */
+    namespace Platform {
+        /**
+         * Platform API for system-level operations.
+         */
+        export interface API {
+            /**
+             * Restart the application/platform.
+             * @param options Optional settings for the restart operation.
+             */
+            restart(options?: ExitOptions): Promise<void>;
+
+            /**
+             * Shutdown the application/platform.
+             * @param options Optional settings for the shutdown operation.
+             */
+            shutdown(options?: ExitOptions): Promise<void>;
+
+            /**
+             * Register a callback to be invoked when the platform is shutting down.
+             * @param callback Function to be called during shutdown. Should return a Promise with prevent flag.
+             * @returns Function to unsubscribe the callback.
+             */
+            onShuttingDown(callback: (args: ShuttingDownEventArgs) => Promise<{ prevent: boolean }>): () => void;
+        }
+
+        /**
+         * Options for shutdown or restart operations.
+         */
+        export interface ExitOptions {
+            /**
+             * If `true`, will save the current Global Layout before shutdown/restart.
+             */
+            autoSave?: boolean;
+
+            /**
+             * If `true`, will show a confirmation dialog when shutting down or restarting.
+             */
+            showDialog?: boolean;
+
+            /**
+             * Optional reason for the shutdown/restart.
+             */
+            reason?: string;
+        }
+
+        /**
+         * Arguments passed to shutdown event handlers.
+         */
+        export interface ShuttingDownEventArgs {
+            /**
+             * If `true`, the platform is restarting rather than shutting down.
+             */
+            restarting: boolean;
+
+            /**
+             * Information about the interop instance that initiated the shutdown.
+             */
+            initiator?: IOConnectDesktop.Interop.Instance;
+
+            /**
+             * Reason for the shutdown.
+             */
+            reason?: string;
+        }
+    }
+
     /**
      * @intro
      * **io.Connect Desktop** provides a way for apps to programmatically capture screenshots of the available monitors, of windows and window groups.
@@ -2129,7 +2632,7 @@ export declare namespace IOConnectDesktop {
              * Notifies when a Layout is renamed.
              * @param callback Callback function for handling the event.
              * Receives as a first argument the `Layout` object describing the renamed Layout.
-             * Receives as a second argument an object with a `name` property holding the previous Layout name.
+             * Receives as a second optional argument an object with a `name` property holding the previous Layout name (if any).
              */
             onRenamed(callback: (layout: Layout, previous: { name: string }) => void): UnsubscribeFunction;
 
@@ -2491,6 +2994,14 @@ export declare namespace IOConnectDesktop {
              */
             setActivityContext?: boolean;
 
+            /**
+             * If `true`, Workspaces saved in a Global Layout will be restored in their original (unmodified) state when the Global Layout is restored.
+             * If `false`, Workspaces will be restored in the exact state in which they were when the Global Layout was saved.
+             * This will override the `"restoreWorkspacesByReference"` property specified in the definition of the Workspaces App.
+             * Defaults to the value of the `"restoreWorkspacesByReference"` property specified in the Workspaces App definition.
+             * @since io.Connect Desktop 10.0
+             */
+            restoreWorkspacesByReference?: boolean;
             /**
              * Only if the type is `"Activity"` and `activityId` is set.
              * With this you can specify that certain window types should not be restored.
@@ -2862,13 +3373,14 @@ export declare namespace IOConnectDesktop {
             focus?: boolean;
 
             /**
-             * If `true`, the window will have move areas and the user will be able to move it. Valid only for io.Connect Windows with `mode` set to `"html"`.
+             * If `true`, the window will have move areas and the user will be able to move it.
+             * Valid only for HTML and frameless io.Connect Windows.
              * @default true
              */
             hasMoveAreas?: boolean;
 
             /**
-             * If `true`, the user will be able to resize the window by dragging its borders. Valid only for io.Connect Windows with `mode` set to `"html"`.
+             * If `true`, the user will be able to resize the window by dragging its borders.
              * @default true
              */
             hasSizeAreas?: boolean;
@@ -3113,12 +3625,14 @@ export declare namespace IOConnectDesktop {
             enabled?: boolean;
 
             /**
-             * Type of the Channel Selector to show on the io.Connect Windows. A single Channel Selector (default) allows the window to join a single Channel
-             * to which it can subscribe and publish data unrestrictedly. A directional single Channel Selector allows the window to join a single Channel,
-             * but also enables the user to restrict the window from publishing or from subscribing to the current Channel.
+             * Type of the Channel Selector to show on the io.Connect Windows.
+             * The single Channel Selector (default) allows the window to join a single Channel to which it can subscribe and publish data unrestrictedly.
+             * The directional single Channel Selector allows the window to join a single Channel, but also enables the user to restrict the window from publishing or from subscribing to the current Channel.
+             * The multi Channel Selector allows the window to join multiple Channels simultaneously to which it can subscribe and publish data unrestrictedly.
+             * The directional multi Channel Selector allows the window to join multiple Channels, but also enables the user to restrict the window from publishing or from subscribing to the currently joined Channels.
              * @default "single"
              */
-            type?: "single" | "directionalSingle";
+            type?: "single" | "directionalSingle" | "multi" | "directionalMulti";
 
             /**
              * Name of the Channel to which the window will be joined by default when it's started.
@@ -3543,12 +4057,88 @@ export declare namespace IOConnectDesktop {
             options: FlydownOptions;
         }
 
+        /**
+         * Options for creating a popup window. The created window will be frameless and hidden.
+         */
+        export interface CreatePopupOptions {
+            /**
+             * Distance of the top left window corner from the left edge of the screen in pixels.
+             * @default 0
+             */
+            left?: number;
+
+            /**
+             * Distance of the top left window corner from the top edge of the screen in pixels.
+             * @default 0
+             */
+            top?: number;
+
+            /**
+             * Window width in pixels.
+             * @default 600
+             */
+            width?: number;
+
+            /**
+             * Window height in pixels.
+             * @default 600
+             */
+            height?: number;
+
+            /**
+             * If `true`, the window will have rounded corners.
+             */
+            roundedCorners?: boolean;
+
+            /**
+             * If `true`, the user will be able to resize the window by dragging its borders.
+             * @default false
+             */
+            hasSizeAreas?: boolean;
+
+            /**
+             * If `true`, the window will have move areas and the user will be able to move it.
+             * @default true
+             */
+            hasMoveAreas?: boolean;
+
+            /**
+             * If `true`, the window will be transparent.
+             * @default false
+             */
+            transparent?: boolean;
+
+            /**
+             * If `true`, the window styles will be copied from the parent window.
+             * @default true
+             */
+            copyStyles?: boolean;
+        }
+
+        /**
+         * Describes the result from creating a popup window via the `createPopup()` method.
+         */
+        export interface CreatePopupResult {
+            /**
+             * The browser window instance of the created popup window.
+             * Can be used to manipulate the DOM content of the created popup window.
+             */
+            browserWindow: Window;
+
+            /**
+             * The io.Connect Window instance of the created popup window.
+             * Can be used to extract the window ID and pass it to the `showPopup()` method in order to display the popup window.
+             */
+            ioConnectWindow: IOConnectWindow;
+        }
+
         /**
          * Options for creating popup windows.
          */
         export interface PopupOptions {
             /**
              * ID of the window which will be used as a popup window.
+             * As of **io.Connect Desktop** 10.0, the popup window must be a frameless window.
              */
             windowId: string;
 
@@ -3568,6 +4158,13 @@ export declare namespace IOConnectDesktop {
              */
             targetLocation: PopupTargetLocation;
 
+            /**
+             * If `true`, the popup window will gain focus when shown and will hide automatically when it loses focus. If `false`, the popup window won't be on focus when shown and won't hide automatically if it gains and loses focus afterwards. If you set this to `false`, you will be responsible for implementing the conditions and the mechanism for hiding/closing the popup window.
+             * @default true
+             * @since io.Connect Desktop 10.0
+             */
+            focus?: boolean;
+
             /**
              * Horizontal offset from the target bounds (applied only to `left` and `right` target locations).
              */
@@ -3817,14 +4414,13 @@ export declare namespace IOConnectDesktop {
         export interface WindowConfiguration {
             /**
              * If `true`, the window will have move areas and the user will be able to move it.
-             * Valid only for io.Connect Windows with `mode` set to `"html"`.
+             * Valid only for HTML and frameless io.Connect Windows.
              * @default true
              */
             hasMoveAreas?: boolean;
 
             /**
              * If `true`, the user will be able to resize the window by dragging its borders.
-             * Valid only for io.Connect Windows with `mode` set to `"html"`.
              * @default true
              */
             hasSizeAreas?: boolean;
@@ -3889,6 +4485,7 @@ export declare namespace IOConnectDesktop {
              * If `true`, the window icon will appear in the taskbar.",
              * @since io.Connect Desktop 9.9
              */
+
             showInTaskbar?: boolean;
 
             /**
@@ -4198,7 +4795,7 @@ export declare namespace IOConnectDesktop {
             /**
              * New bounds for the io.Connect Window. If this is provided, the `restoreBounds` property will be ignored.
              */
-            newBounds?: Partial<Bounds>;
+            newBounds?: Bounds;
         }
 
         /**
@@ -4217,22 +4814,22 @@ export declare namespace IOConnectDesktop {
             /**
              * Window neighbors on the left side of the io.Connect Window.
              */
-            leftNeighbours: IOConnectWindow[];
+            left: IOConnectWindow[];
 
             /**
              * Window neighbors on top of the io.Connect Window.
              */
-            topNeighbours: IOConnectWindow[];
+            top: IOConnectWindow[];
 
             /**
              * Window neighbors on the right side of the io.Connect Window.
              */
-            rightNeighbours: IOConnectWindow[];
+            right: IOConnectWindow[];
 
             /**
              * Window neighbors to the bottom of the io.Connect Window.
              */
-            bottomNeighbours: IOConnectWindow[];
+            bottom: IOConnectWindow[];
         }
 
         /**
@@ -4720,6 +5317,7 @@ export declare namespace IOConnectDesktop {
              */
             value?: string;
         }
+
         /**
          * Options for dragging a window.
          */
@@ -4738,6 +5336,38 @@ export declare namespace IOConnectDesktop {
                 y: number;
             }
         }
+
+        /**
+         * Position of the docked window on the screen - top, bottom, left or right.
+         */
+        export type DockingPosition = "top" | "left" | "right" | "bottom";
+
+        /**
+         * Docking configuration for a window.
+         */
+        export interface DockingConfig {
+            /**
+             * If `true`, will enable docking the window to a screen edge.
+             */
+            enabled: boolean;
+            /**
+             * If `true`, the window will claim the area it occupies on the screen when docked, in effect, reducing the working area of the screen.
+             */
+            claimScreenArea?: boolean;
+            /**
+             * Allowed positions for docking the window. Default is [ "top" ].
+             */
+            allowedPositions?: DockingPosition[];
+            /**
+             * Width in pixels for the window when docked at the left or the right screen edge.
+             */
+            width?: number;
+            /**
+             * Height in pixels for the window when docked at the top or the bottom screen edge.
+             */
+            height?: number;
+        }
+
         /**
          * Describes a docked window.
          */
@@ -4749,7 +5379,7 @@ export declare namespace IOConnectDesktop {
             /**
              * Position of the docked window on the screen - top, bottom, left or right.
              */
-            position?: string;
+            position?: DockingPosition;
             /**
              * If `true`, the docked window claims the area it occupies on the screen, in effect, reducing the working area of the screen.
              */
@@ -4763,11 +5393,44 @@ export declare namespace IOConnectDesktop {
             /**
              * Position of the docked window on the screen - top, bottom, left or right.
              */
-            position: "top" | "bottom" | "left" | "right";
+            position: DockingPosition;
             /**
              * If `true`, the docked window will claim the area it occupies on the screen, in effect, reducing the working area of the screen.
+             * @default false
              */
             claimScreenArea?: boolean;
+            /**
+             * Width in pixels for the window when docked at the left or the right screen edge.
+             * @since io.Connect Desktop 10.0
+             */
+            width?: number;
+            /**
+             * Height in pixels for the window when docked at the top or the bottom screen edge.
+             * @since io.Connect Desktop 10.0
+             */
+            height?: number;
+            /**
+             * If `true`, the last known bounds of the io.Connect Window will be saved unless the window has already been docked.
+             * This allows the window to be restored using these saved bounds when undocking via the `undock()` method.
+             * @default false
+             * @since io.Connect Desktop 10.0
+             */
+            saveBounds?: boolean;
+        }
+
+        /**
+         * Settings for undocking the window.
+         */
+        export interface UndockingOptions {
+            /**
+             * If `true`, the io.Connect Window will be restored to its last known bounds saved in the `dock()` method if `saveBounds` has been set to `true`.
+             */
+            restoreBounds?: boolean;
+
+            /**
+             * New bounds for the io.Connect Window. If this is provided, the `restoreBounds` property will be ignored.
+             */
+            newBounds?: Bounds;
         }
 
         /**
@@ -4876,8 +5539,9 @@ export declare namespace IOConnectDesktop {
             close(options?: CloseOptions): Promise<void>;
 
             /**
-             * Creates a popup window.
-             * @param config Options for creating a popup window.
+             * Shows a popup window.
+             * As of **io.Connect Desktop** 10.0, the popup window must be a frameless window.
+             * @param config Options for showing a popup window.
              * @since io.Connect Desktop 9.3
              */
             showPopup(config: PopupOptions): Promise<void>;
@@ -4910,7 +5574,7 @@ export declare namespace IOConnectDesktop {
              * Notifies when the window group is about to be closed.
              * @param callback Callback function for handling the event. Returns a `Promise` that will be awaited before the window group is closed. The timeout for waiting is 30 seconds. A function for preventing the closing is passed to the callback as a parameter.
              */
-            onClosing(callback: (prevent: (options?: PreventClosingOptions) => void) => Promise<void>): void;
+            onClosing(callback: (prevent: (options?: PreventClosingOptions) => void) => Promise<void>): UnsubscribeFunction;
         }
 
         /**
@@ -4968,9 +5632,17 @@ export declare namespace IOConnectDesktop {
             createFlydown(targetWindowId: string, config: FlydownOptions): Promise<Flydown>;
 
             /**
-             * Creates a popup window.
-             * @param targetWindowId ID of the window for which to create the popup.
-             * @param config Options for creating a popup window.
+             * Creates a window to be used as a popup window. The created window will be frameless and hidden.
+             * @param options Options for creating a popup window.
+             * @since io.Connect Desktop 10.0
+             */
+            createPopup(options: CreatePopupOptions): Promise<CreatePopupResult>;
+
+            /**
+             * Shows a popup window.
+             * As of **io.Connect Desktop** 10.0, the popup window must be a frameless window.
+             * @param targetWindowId ID of the window for which to show the popup.
+             * @param config Options for showing a popup window.
              */
             showPopup(targetWindowId: string, config: PopupOptions): Promise<void>;
 
@@ -5113,6 +5785,11 @@ export declare namespace IOConnectDesktop {
              */
             application: AppManager.Application | undefined;
 
+            /**
+             * Name of the app associated with the current window. Can be `undefined` if the window wasn't started as an app.
+             */
+            appName: string | undefined;
+
             /**
              * Title of the current window.
              */
@@ -5643,7 +6320,8 @@ export declare namespace IOConnectDesktop {
 
             /**
              * Shows a popup window.
-             * @param config Options for the popup window.
+             * As of **io.Connect Desktop** 10.0, the popup window must be a frameless window.
+             * @param config Options for showing a popup window.
              */
             showPopup(config: PopupOptions): Promise<IOConnectWindow>;
 
@@ -5726,6 +6404,11 @@ export declare namespace IOConnectDesktop {
              */
             getContext(): Promise<any>;
 
+            /**
+             * Retrieves the application associated with the current window.
+             */
+            getApplication(): Promise<Apps.Application | undefined>;
+
             /**
              * Sets the window context.
              */
@@ -5775,10 +6458,16 @@ export declare namespace IOConnectDesktop {
             getConfiguration(): Promise<WindowConfiguration>;
 
             /**
-             * Retrieves the current Channel of the window, if any.
+             * Retrieves the name of the currently joined Channel, if any.
              */
             getChannel(): Promise<string | undefined>;
 
+            /**
+             * Retrieves the names of all currently joined Channels, if any.
+             * @since io.Connect Desktop 10.0
+             */
+            getChannels(): Promise<string[]> | undefined;
+
             /**
              * Enables moving files from a web page to the OS when a user starts dragging a web page element.
              * Based on the Electron [Native File Drag & Drop](https://www.electronjs.org/docs/latest/tutorial/native-file-drag-drop) functionality.
@@ -5855,6 +6544,19 @@ export declare namespace IOConnectDesktop {
              */
             getDockingPlacement(): Promise<DockingPlacement>;
 
+            /**
+             * Sets the docking configuration for the window. This will override the docking configuration specified in the app definition.
+             * @param config Docking settings.
+             * @since io.Connect Desktop 10.0
+             */
+            setDockingConfig(config: DockingConfig): Promise<void>;
+
+            /**
+             * Retrieves the current docking configuration for the window as specified in the app definition or as previously set via the `setDockingConfig()` method.
+             * @since io.Connect Desktop 10.0
+             */
+            getDockingConfig(): Promise<DockingConfig>;
+
             /**
              * Docks the window at the specified position.
              * @param options Options for docking the window.
@@ -5862,6 +6564,13 @@ export declare namespace IOConnectDesktop {
              */
             dock(options: DockingOptions): Promise<DockingPlacement>;
 
+            /**
+             * Undocks the window if it is already docked.
+             * @param options Options for undocking the window.
+             * @since io.Connect Desktop 10.0
+             */
+            undock(options?: UndockingOptions): Promise<void>;
+
             /**
              * Notifies when a window is attached to the current window.
              * @param callback Callback function for handling the event.
@@ -6018,7 +6727,7 @@ export declare namespace IOConnectDesktop {
              * before the window is closed. The timeout for waiting is subject to configuration in **io.Connect Desktop**.
              * A function for preventing the closing is passed to the callback as a parameter.
              */
-            onClosing(callback: (prevent: (options?: PreventClosingOptions) => void) => Promise<void>): void;
+            onClosing(callback: (prevent: (options?: PreventClosingOptions) => void) => Promise<void>): UnsubscribeFunction;
 
             /**
              * Notifies when the window is about to be refreshed.
@@ -6026,7 +6735,7 @@ export declare namespace IOConnectDesktop {
              * before the window is refreshed. The timeout for waiting is subject to configuration in **io.Connect Desktop**.
              * A function for preventing the refresh is passed to the callback as a parameter.
              */
-            onRefreshing(callback: (prevent: () => void) => Promise<void>): void;
+            onRefreshing(callback: (prevent: () => void) => Promise<void>): UnsubscribeFunction;
 
             /**
              * Notifies when the zoom factor is changed.
@@ -6050,7 +6759,7 @@ export declare namespace IOConnectDesktop {
              * Notifies when the window is about to be navigated to a new URL.
              * @param callback Callback function for handling the event.
              */
-            onNavigating(callback: (args: { newUrl: string }) => Promise<void>): void;
+            onNavigating(callback: (args: { newUrl: string }) => Promise<void>): UnsubscribeFunction;
 
             /**
              * Notifies when the window docking placement is changed.
@@ -6373,7 +7082,7 @@ export declare namespace IOConnectDesktop {
             /**
              * Notifies when the current window joins or leaves a Channel. Returns an unsubscribe function.
              * It's recommended to use the `onChannelsChanged()` method instead, which can handle Channel changes both in single and in multi Channel mode.
-             * @param callback Callback function for handling the event. Receives as an argument the name of the Channel which the window has joined or left.
+             * @param callback Callback function for handling the event. Receives as an argument the name of the newly joined Channel. If the window leaves a Channel without joining a new one, the argument will be `undefined`.
              */
             onChanged(callback: (channel: string) => void): () => void;
 
@@ -6613,7 +7322,7 @@ export declare namespace IOConnectDesktop {
              * Whether the current app has registered a hotkey.
              * @param hotkey The name of the hotkey you want to check.
              */
-            isRegistered(hotkey: string): void;
+            isRegistered(hotkey: string): boolean;
         }
     }
 
@@ -6661,14 +7370,14 @@ export declare namespace IOConnectDesktop {
              * @param callback Callback function for handling the event. Receives an object describing the added Intent handler as an argument.
              * @since io.Connect Desktop 9.6
              */
-            onHandlerAdded(callback: (handler: IOConnectDesktop.Intents.IntentHandler) => void, intentName: string): UnsubscribeFunction;
+            onHandlerAdded(callback: (handler: IOConnectDesktop.Intents.IntentHandler, intentName: string) => void): UnsubscribeFunction;
 
             /**
              * Notifies when a handler for an Intent is removed. Returns an unsubscribe function.
              * @param callback Callback function for handling the event. Receives an object describing the removed Intent handler as an argument.
              * @since io.Connect Desktop 9.6
              */
-            onHandlerRemoved(callback: (handler: IOConnectDesktop.Intents.IntentHandler) => void, intentName: string): UnsubscribeFunction;
+            onHandlerRemoved(callback: (handler: IOConnectDesktop.Intents.IntentHandler, intentName: string) => void): UnsubscribeFunction;
 
             /**
              * Registers an Intent handler. If your app is already registered as an Intent handler through its configuration,
@@ -7765,7 +8474,7 @@ export declare namespace IOConnectDesktop {
                 enabled?: boolean;
                 /**
                  * Interval in milliseconds for which the notifications will be snoozed.
-                 * @default 600000
+                 * @default 60000
                  */
                 duration?: number;
             };
@@ -7774,11 +8483,6 @@ export declare namespace IOConnectDesktop {
              * If `true`, will enable showing a notification badge on the tray menu icon, in the "Notifications" section of the io.Connect launcher, and on the taskbar icon of the io.Connect launcher (or your shell app).
              */
             showNotificationBadge?: boolean;
-
-            /**
-             * If `true`, the Notification Panel will be hidden automatically when it loses focus.
-             */
-            autoHidePanel?: boolean;
         }
 
         /**
@@ -7830,7 +8534,7 @@ export declare namespace IOConnectDesktop {
              * Notifies when the theme is changed.
              * @param callback Callback function for handling the event.
              */
-            onChanged(callback: (theme: IOConnectDesktop.Themes.Theme) => any): void;
+            onChanged(callback: (theme: IOConnectDesktop.Themes.Theme) => any): UnsubscribeFunction;
         }
 
         /**