@interopio/desktop 6.16.0 → 6.16.2

package/desktop.d.ts

@@ -271,7 +271,7 @@ export declare namespace IOConnectDesktop {
      * - application state synchronization via Activity context management functions;
      * - intra-Activity application collaboration via Activity Interop extension functions;
      *
-     * The Activities API is accessible through the `io.activities` object.
+     * The Activities API is accessible via the `io.activities` object.
      */
     namespace Activities {
 
@@ -974,9 +974,9 @@ 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.
+     * The App Management API is accessible via the [`io.appManager`](#API) object.
      *
-     * @deprecated The AppManager API is deprecated. Use the new Apps API (`io.apps`) instead.
+     * > ⚠️ *Note that the App Management API has been deprecated and will be entirely removed in a future release. Use the Apps API accessible via the [`io.apps`](../apps/index.html#API) object instead.*
      */
     namespace AppManager {
         /**
@@ -1676,9 +1676,10 @@ export declare namespace IOConnectDesktop {
         export type Roles = "Full" | "ReadWrite" | "ReadOnly";
 
         /**
-         * App definition.
+         * App definition. All available app definition properties are described in the `application.json` JSON schema of **io.Connect Desktop**.
          */
-        export type Definition = ApplicationConfig
+        export interface Definition extends ApplicationConfig {
+        }
 
         /**
          * Describes an Intent.
@@ -1712,103 +1713,116 @@ 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.
+     * @intro
+     * > ⚠️ *Note that the Apps API is still an experimental feature. This means that it may have hidden issues and may be subject to changes in future releases.*
+     * >
+     * > The Apps API is designed to replace the legacy App Management API accessible via the [`io.appManager`](../app%20management/index.html#API) object.
+     * > The legacy App Management API is still supported, but will be entirely removed in a future release. It's highly recommended to migrate to the new Apps API.*
+     *
+     * The Apps API provides a modern, fully asynchronous way to manage **io.Connect Desktop** apps. It offers abstractions for:
+     *
+     * - App - a program as a logical entity, registered in **io.Connect Desktop** with some metadata (name, description, icon, etc.)
+     * and with all the configuration needed to spawn one or more instances of it.
+     * The Apps API provides facilities for retrieving app metadata and for detecting when an app is started.
+     *
+     * - Instance - a running copy of an app. The Apps API provides facilities for starting/stopping app instances and tracking app-related events.
+     *
+     * The Apps API is accessible via the [`io.apps`](#API) object.
+     *
+     * *Available since io.Connect Desktop 10.0.*
      */
     namespace Apps {
+
         /**
-         * App Management API.
+         * Apps 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.
+             * Provides access to the current app instance.
              */
             readonly my: My;
 
             /**
-             * App registry for managing app definitions and metadata.
+             * Object that that can be used for managing app definitions.
              */
             readonly registry: AppRegistry;
 
             /**
-             * Instance manager for controlling running app instances.
+             * Object that can be used for managing 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.
+         * Provides access to the current app instance.
          */
         export interface My {
+
             /**
-             * The current application instance.
+             * Describes the current app instance.
              */
             readonly instance: ApplicationInstance;
 
             /**
-             * My application name.
+             * The name of the current app.
              */
             readonly appName: string;
         }
 
         /**
-         * App registry for managing app definitions and metadata.
+         * Object that can be used for managing app definitions.
          */
         export interface AppRegistry {
+
             /**
-             * API for handling app definitions at runtime.
-             * The API methods operate only on in-memory app definitions.
+             * Object that can be used for handling app definitions dynamically.
              */
             readonly inMemory: InMemoryStore;
 
             /**
-             * Retrieves an app definition by name.
-             * @param options Options for retrieving the app definition.
+             * Retrieves an app by name.
+             * @param options Options for retrieving the app.
              */
             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.
+             * Retrieves all available apps. You can also provide an optional filter to refine the result.
+             * @param filter Filter for retrieving apps.
              */
             getMany(filter?: AppFilter): Promise<Application[]>;
 
             /**
-             * Checks if an app exists and is available.
+             * Checks if an app exists in the app registry.
              * @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.
+             * Notifies when an app has been registered in the environment. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument an object describing the added app.
              */
             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.
+             * Notifies when an app has been removed from the environment. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument the name of the removed app.
              */
             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.
+             * Notifies when an app has been updated. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument an object describing the updated app and the new values of the updated app properties.
              */
             onUpdated(handler: AppEventHandler<AppUpdatedEvent>): Promise<UnsubscribeFunction>;
 
         }
 
         /**
-         * Instance manager for controlling running app instances.
+         * Object that can be used for managing running app instances.
          */
         export interface InstanceManager {
+
             /**
              * Starts a new app instance.
              * @param options Options for starting the app instance.
@@ -1822,33 +1836,32 @@ export declare namespace IOConnectDesktop {
             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.
+             * Waits for an app instance to be fully initialized.
+             * @param options Filter for selecting an app instance.
              */
             waitForReady(options: InstanceSelect): Promise<void>;
 
             /**
-             * Retrieves an app instance by ID.
-             * @param options Options for selecting the instance.
+             * Retrieves an app instance.
+             * @param options Filter for selecting an app instance.
              */
             get(options: InstanceSelect): Promise<ApplicationInstance | null>;
 
             /**
-             * Retrieves all running app instances with optional filtering.
-             * @param filter Optional filter criteria for instances.
+             * Retrieves all running app instances. You can also provide an optional filter to refine the result.
+             * @param filter Filter for retrieving app instances.
              */
             getMany(filter?: InstanceFilter): Promise<ApplicationInstance[]>;
 
             /**
-             * Retrieves the state of an app instance.
-             * @param options Options for selecting the instance.
+             * Retrieves the current state of an app instance.
+             * @param options Filter for selecting an app instance.
              */
             getState(options: InstanceSelect): Promise<InstanceState>;
 
             /**
              * Retrieves the context of an app instance.
-             * @param options Options for selecting the instance.
+             * @param options Filter for selecting an app instance.
              */
             getContext(options: InstanceSelect): Promise<Record<string, any>>;
 
@@ -1859,339 +1872,681 @@ export declare namespace IOConnectDesktop {
             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.
+             * Notifies when an app instance has been started. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument an object describing the started app instance.
              */
             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.
+             * Notifies when an app instance has been stopped. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument an object describing the stopped app instance and a reason (optional) for stopping the instance.
              */
             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.
+             * Notifies when the current state an app instance has been changed. Returns an unsubscribe function.
+             * @param handler Callback function for handling the event. Receives as an argument an object describing the app instance and its new state.
              */
             onStateChanged(handler: InstanceEventHandler<InstanceStateChangedEvent>): Promise<UnsubscribeFunction>;
         }
 
         /**
-         * API for handling app definitions at runtime.
-         * The API methods operate only on in-memory app definitions.
+         * Object that can be used for handling app definitions dynamically. The described 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 definitions Array of app definition objects to be imported in the in-memory store.
              * @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.
+             * Checks if an app definition is available in the in-memory store.
+             * @param name The name of the app for whose definition to check.
              */
             has(name: string): Promise<boolean>;
 
             /**
              * Removes an app definition from the in-memory store.
-             * @param options Remove options.
+             * @param options Options for removing an app definition.
              */
             remove(options: RemoveAppOptions): Promise<void>;
 
             /**
-             * Removes all app definitions from the in-memory store.
-             * @param options Clear options.
+             * Clears all app definitions from the in-memory store.
+             * @param options Options for clearing app definitions.
              */
             clear(options?: ClearAppsOptions): Promise<void>;
         }
 
-        // Event Types
-        export type AppAddedEvent = { app: ApplicationCore; };
-        export type AppRemovedEvent = { appName: string; };
-        export type AppUpdatedEvent = { app: ApplicationCore; changes: AppChangeSet };
+        /**
+         * Describes the argument received by the callback function for handling the app added event.
+         */
+        export interface AppAddedEvent {
+
+            /**
+             * Describes the app that has been added to the environment.
+             */
+            app: ApplicationCore;
+        }
+
+        /**
+         * Describes the argument received by the callback function for handling the app removed event.
+         */
+        export interface AppRemovedEvent {
+
+            /**
+             * The name of the app that has been removed from the environment.
+             */
+            appName: string;
+        }
+
+        /**
+         * Describes the argument received by the callback function for handling the app updated event.
+         */
+        export interface AppUpdatedEvent {
+
+            /**
+             * Describes the app that has been updated.
+             */
+            app: ApplicationCore;
+
+            /**
+             * Object with key/value pairs describing the updated app properties and their new values.
+             */
+            changes: AppChangeSet;
+        }
+
+        /**
+         * Describes the argument received by the callback function for handling the instance started event.
+         */
+        export interface InstanceStartedEvent {
+
+            /**
+             * Describes the app instance that has been started.
+             */
+            instance: ApplicationInstance;
+        }
 
-        export type InstanceStartedEvent = { instance: ApplicationInstance; };
-        export type InstanceStoppedEvent = { instance: ApplicationInstance; reason?: string; };
-        export type InstanceStateChangedEvent = { instance: ApplicationInstance; state: InstanceState }
+        /**
+         * Describes the argument received by the callback function for handling the instance stopped event.
+         */
+        export interface InstanceStoppedEvent {
+
+            /**
+             * Describes the app instance that has been stopped.
+             */
+            instance: ApplicationInstance;
+
+            /**
+             * Reason for stopping the app instance.
+             */
+            reason?: string;
+        }
 
-        // Event Handlers
+        /**
+         * Describes the argument received by the callback function for handling the instance state changed event.
+         */
+        export interface InstanceStateChangedEvent {
+
+            /**
+             * Describes the app instance whose state has changed.
+             */
+            instance: ApplicationInstance;
+
+            /**
+             * The current state of the app instance.
+             */
+            state: InstanceState;
+        }
+
+        /**
+         * Handler for app events.
+         */
         export type AppEventHandler<T> = (event: T) => void;
+
+        /**
+         * Handler for app instance events.
+         */
         export type InstanceEventHandler<T> = (event: T) => void;
 
+        /**
+         * Describes the basic properties of an app.
+         */
         export interface ApplicationCore {
+
+            /**
+             * Name of the app.
+             */
             readonly name: string;
+
+            /**
+             * Type of the app.
+             */
             readonly type: AppType;
+
+            /**
+             * Title of the app.
+             */
             readonly title?: string;
+
+            /**
+             * Version of the app.
+             */
             readonly version?: string;
+
+            /**
+             * Description of the app.
+             */
             readonly description?: string;
+
+            /**
+             * Icon URL or the icon of the app in Base64 format.
+             */
             readonly icon?: string;
+
+            /**
+             * URL of the app icon.
+             */
             readonly iconURL?: string;
+
+            /**
+             * Keywords for the app.
+             */
             readonly keywords?: string[];
+
+            /**
+             * Flag indicating whether the app will be auto started on platform startup.
+             */
             readonly autoStart?: boolean;
+
+            /**
+             * Flag indicating whether multiple instances of the app are allowed.
+             */
             readonly allowMultiple?: boolean;
+
+            /**
+             * Flag indicating whether the app is running as a hidden window.
+             */
             readonly isHidden?: boolean;
+
+            /**
+             * Flag indicating whether the app is a shell app for the platform.
+             */
             readonly isShell?: boolean;
+
+            /**
+             * Flag indicating whether the app is part of the in-memory store.
+             */
             readonly isInMemory?: boolean;
         }
 
-        // Core Data Types
+        /**
+         * Describes an app.
+         */
         export interface Application extends ApplicationCore {
+
+            /**
+             * Provides access to the FDC3 app definition if this is an FDC3 app.
+             */
             fdc3?: Record<string, any>;
+
+            /**
+             * Provides access to the custom properties specified in the app definition if such exist.
+             */
             customProperties?: Record<string, any>;
+
+            /**
+             * Provides access to the entire app definition.
+             */
             definition?: Definition;
+
+            /**
+             * Array of objects describing all currently available app instances.
+             */
             instances?: ApplicationInstance[];
         }
 
+        /**
+         * Describes an app instance.
+         */
         export interface ApplicationInstance {
+
+            /**
+             * ID of the app instance.
+             */
             id: string;
+
+            /**
+             * Name of the app as specified in its definition to which the instance belongs.
+             */
             appName: string;
+
+            /**
+             * Timestamp of when the app instance was started.
+             */
             startedAt: Date;
+
+            /**
+             * Describes how the current app instance was started and provides details about the app that started it.
+             */
             startedBy: StartedByInfo;
-            interopInstance?: Promise<IOConnectDesktop.Interop.Instance>;
+
+            /**
+             * Provides access to the Interop instance of the current app instance.
+             */
+            interopInstance?: IOConnectDesktop.Interop.Instance;
+
+            /**
+             * Process ID of the current app instance.
+             */
             pid?: number;
         }
 
-        // Filter Types
+        /**
+         * Filter for retrieving apps.
+         */
         export interface AppFilter extends AppDataOptions {
+
+            /**
+             * Array of app names as specified in the respective app definitions.
+             */
             readonly names?: string[];
+
+            /**
+             * Array of app types as specified in the respective app definitions.
+             */
             readonly types?: AppType[];
+
+            /**
+             * If `true`, the result will include only apps that are specified as hidden in their app definitions.
+             */
             readonly isHidden?: boolean;
+
+            /**
+             * If `true`, the result will include only FDC3 app definitions.
+             */
             readonly isFdc3Definition?: boolean;
+
+            /**
+             * If `true`, the result will include only apps from the in-memory app store.
+             */
             readonly isInMemory?: boolean;
+
+            /**
+             * Array of keywords as specified in the respective app definitions.
+             */
             readonly keywords?: string[];
+
+            /**
+             * Custom properties as specified in the respective app definition.
+             */
             readonly customProperties?: Record<string, any>;
         }
 
+        /**
+         * Filter for retrieving app instances.
+         */
         export interface InstanceFilter {
+
+            /**
+             * Array of app instance IDs.
+             */
             readonly ids?: string[];
+
+            /**
+             * Array of app names as specified in the respective app definitions.
+             * Using this as a filter will include in the result all currently available instances of the specified apps.
+             */
             readonly appNames?: string[];
+
+            /**
+             * Only the app instances started after the specified timestamp will be included in the result.
+             */
             readonly startedAfter?: Date;
+
+            /**
+             * Only the app instances started before the specified timestamp will be included in the result.
+             */
             readonly startedBefore?: Date;
         }
 
-        // Options Types
+        /**
+         * Options for retrieving apps.
+         */
         export interface GetAppOptions extends AppSelect, AppDataOptions {
         }
 
+        /**
+         * Options for selecting apps.
+         */
         export interface AppSelect {
+
+            /**
+             * Name of the app as specified in its app definition.
+             */
             readonly name: string;
         }
 
+        /**
+         * Options for selecting or filtering apps.
+         */
         export interface AppDataOptions {
+
             /**
-             * If true, the app definition will be included in the result.
+             * 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.
+             * If `true`, all currently available app instances will be included in the result.
              * @default true
              */
             readonly includeInstances?: boolean;
         }
 
+        /**
+         * Options for starting an app instance.
+         */
         export interface StartAppOptions {
+
+            /**
+             * Name of the app to start as specified in its app definition.
+             */
             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.
+             * Context to pass to the started app instance.
+             * If not provided, the context from the app definition will be used if such exists.
+             * Otherwise, this will be set to an empty object.
              */
             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.
+             * Key/value pairs of app definition overrides to apply when starting the app instance.
+             * The values of the app definition properties specified here will override the values of the respective properties in the already existing app definition.
              */
             readonly definitionOverride?: Record<string, any>;
+
             /**
-             * The timeout for the start operation in milliseconds.
+             * Interval in milliseconds to wait for starting the app instance.
              * @default 120000
              */
             readonly timeout?: number;
+
             /**
-             * If true, the app will attempt to reuse an existing instance if available.
+             * If `true`, the platform will attempt to reuse an existing instance of the specified app if such is available.
              * @default false
              */
             readonly reuseInstance?: boolean;
         }
 
+        /**
+         * Options for stopping an app instance.
+         */
         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.
+             * 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.
+             * Interval in milliseconds to wait for stopping the app instance.
              * @default 30000
              */
             readonly timeout?: number;
+
             /**
-             * Optional reason for stopping the instance.
+             * Reason for stopping the app instance.
              */
             readonly reason?: string;
         }
 
+        /**
+         * Options for restarting an app instance.
+         */
         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.
+             * If you provide `"preserve"` as a value, the context of the original instance will be reused.
+             * If you provide `"clear"` as a value, the context of the restarted instance will reset to an empty object.
              * @default "preserve"
              */
             readonly context?: Record<string, any> | "preserve" | "clear";
+
             /**
-             * If true, the original app definition is used for the restarted instance.
+             * If `true`, the original app definition will be used for the restarted instance.
              * @default false
              */
             readonly useOriginalDefinition?: boolean;
+
             /**
-             * The timeout for the restart operation.
+             * Interval in milliseconds to wait for restarting the app instance.
              * @default 120000
              */
             readonly timeout?: number;
         }
 
+        /**
+         * @ignore
+         */
         export interface ImportOptions {
             readonly mode?: "replace" | "merge";
             readonly validateOnly?: boolean;
             readonly skipInvalid?: boolean;
         }
 
+        /**
+         * @ignore
+         */
         export interface ExportOptions {
             readonly includeConfiguration?: boolean;
             readonly includeMetadata?: boolean;
         }
 
+        /**
+         * Options for removing and app definition from the in-memory store.
+         */
         export interface RemoveAppOptions {
+
+            /**
+             * Name of the app whose definition to remove.
+             */
             readonly name: string;
+
+            /**
+             * If `true`, all currently running instances of the app will be stopped.
+             * @default false
+             */
             readonly stopInstances?: boolean;
         }
 
+        /**
+         * Options for clearing all app definitions from the in-memory store.
+         */
         export interface ClearAppsOptions {
+
+            /**
+             * If `true`, all currently running instances of all apps from the in-memory store will be stopped.
+             * @default false
+             */
             readonly stopAllInstances?: boolean;
+
+            /**
+             * @ignore
+             * If `true`, the definitions of all system apps will be preserved after clearing the in-memory store.
+             * @default false
+             */
             readonly preserveSystemApps?: boolean;
         }
 
+        /**
+         * Options for selecting an app instance.
+         */
         export interface InstanceSelect {
+
+            /**
+             * ID of the app instance.
+             */
             readonly id: string;
         }
 
-        // Enum Types
-        export type AppType = ApplicationConfig["type"];
+        /**
+         * Type of the app.
+         */
+        export type AppType = "window" | "activity" | "exe" | "node" | "workspaces" | "webGroup" | "clickonce" | "citrix" | "childWindow";
+
+        /**
+         * Current state of the app instance.
+         */
         export type InstanceState = "started" | "ready" | "stopped" | "failed";
 
+        /**
+         * Object with key/value pairs describing the updated app properties and their new values.
+         */
         export interface AppChangeSet {
+
+            /**
+             * Kay/value pair holding the name of the updated app property and its new value respectively.
+             */
             readonly [key: string]: any;
         }
 
-        export type Definition = ApplicationConfig;
+        /**
+         * App definition object. All available app definition properties are described in the `application.json` JSON schema of **io.Connect Desktop**.
+         */
+        export interface Definition extends ApplicationConfig {
+        }
 
+        /**
+         * Describes the result from importing app definitions at runtime.
+         */
         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>;
-            }[];
+
+            /**
+             * Array of names of the successfully imported apps as specified in their definitions.
+             */
+            imported: string[];
+
+            /**
+             * Array of objects describing any errors from importing the app definitions.
+             */
+            errors: { app: string; error: string }[];
         }
 
-        // Re-export common types from legacy namespace for compatibility
-        export import StartedByInfo = IOConnectDesktop.AppManager.StartedByInfo;
+        /**
+         * Describes how the current app instance was started and provides details about the app that started it.
+         */
+        export interface StartedByInfo {
+
+            /**
+             * Indicates how the current app instance was started. Apps can be started by other apps, by a raised Intent, or can be auto started by the system.
+             */
+            startedBy: "application" | "intent" | "autoStart";
+
+            /**
+             * Name of the app that started the current app instance.
+             */
+            applicationName: string;
+
+            /**
+             * ID of the app instance that started the current app instance.
+             */
+            instanceID: string;
+        }
     }
 
     /**
      * @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 provides facilities for managing system-level events like restarting or shutting down the io.Connect platform.
+     *
+     * The Platform API is accessible via the [`io.platform`](#API) object.
      *
-     * The Platform API is accessible through the `io.platform` object.
+     * *Available since io.Connect Desktop 10.0.*
      */
     namespace Platform {
+
         /**
-         * Platform API for system-level operations.
+         * Platform API.
          */
         export interface API {
+
             /**
-             * Restart the application/platform.
-             * @param options Optional settings for the restart operation.
+             * Restarts the io.Connect platform.
+             * @param options Settings for the restart operation.
              */
             restart(options?: ExitOptions): Promise<void>;
 
             /**
-             * Shutdown the application/platform.
-             * @param options Optional settings for the shutdown operation.
+             * Shuts down the io.Connect platform.
+             * @param options 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.
+             * Notifies when the io.Connect platform is about to be shut down or restarted.
+             * @param callback Callback function for handling the event. You can use this callback to execute custom code
+             * before the platform shuts down or restarts. The available time for the execution of your code is 60 seconds.
+             * To prevent the platform shutdown or restart, the callback must resolve with an object with a `prevent` property set to `true`.
              */
             onShuttingDown(callback: (args: ShuttingDownEventArgs) => Promise<{ prevent: boolean }>): () => void;
         }
 
         /**
-         * Options for shutdown or restart operations.
+         * Options for platform shutdown or restart.
          */
         export interface ExitOptions {
+
             /**
-             * If `true`, will save the current Global Layout before shutdown/restart.
+             * If `true`, will save the current Global Layout before shutdown or restart of the platform.
              */
             autoSave?: boolean;
 
             /**
-             * If `true`, will show a confirmation dialog when shutting down or restarting.
+             * If `true`, will show a confirmation dialog when shutting down or restarting the platform.
              */
             showDialog?: boolean;
 
             /**
-             * Optional reason for the shutdown/restart.
+             * Reason for the platform shutdown or restart.
              */
             reason?: string;
         }
 
         /**
-         * Arguments passed to shutdown event handlers.
+         * Describes the argument received by the callback function for handling the platform shutdown event.
          */
         export interface ShuttingDownEventArgs {
+
             /**
-             * If `true`, the platform is restarting rather than shutting down.
+             * Flag indicating whether the platform is being restarted.
              */
             restarting: boolean;
 
             /**
-             * Information about the interop instance that initiated the shutdown.
+             * Information about the Interop instance that has initiated the platform shutdown or restart.
              */
             initiator?: IOConnectDesktop.Interop.Instance;
 
             /**
-             * Reason for the shutdown.
+             * Reason for the platform shutdown or restart.
              */
             reason?: string;
         }
@@ -2202,7 +2557,7 @@ export declare namespace IOConnectDesktop {
      * **io.Connect Desktop** provides a way for apps to programmatically capture screenshots of the available monitors, of windows and window groups.
      * Based on custom logic, you can capture one or all monitors in order to save a snapshot of the visual state at a given moment.
      *
-     * The Displays API is accessible through the `io.displays` object.
+     * The Displays API is accessible via the [`io.displays`](#API) object.
      */
     namespace Displays {
         /**
@@ -2420,7 +2775,7 @@ export declare namespace IOConnectDesktop {
      *
      * The Layouts library supports different types of Layouts - Global, App Default, Workspace.
      *
-     * The Layouts API is accessible through the `io.layouts` object.
+     * The Layouts API is accessible via the [`io.layouts`](#API) object.
      */
     namespace Layouts {
 
@@ -3172,7 +3527,7 @@ export declare namespace IOConnectDesktop {
      * - From an end user perspective, there is no difference between web or native windows.
      * - Feature parity is provided by the different technology adapters.
      *
-     * The Window Management API is accessible through the `io.windows` object.
+     * The Window Management API is accessible via the [`io.windows`](#API) object.
      */
     namespace Windows {
 
@@ -6896,7 +7251,7 @@ export declare namespace IOConnectDesktop {
      * instructing them to work over the same shared data object.
      * When apps are on the same Channel, they share a context data object which they can monitor and/or update.
      *
-     * The Channels API is accessible through the `io.channels` object.
+     * The Channels API is accessible via the [`io.channels`](#API) object.
      */
     namespace Channels {
 
@@ -7273,7 +7628,7 @@ export declare namespace IOConnectDesktop {
      * when a key combination is pressed by the user regardless of whether or not the app is on focus.
      * Hotkeys are useful for web apps that don't have access to system resources and can't register global shortcuts.
      *
-     * The Hotkeys API is accessible through the `io.hotkeys` object.
+     * The Hotkeys API is accessible via the [`io.hotkeys`](#API) object.
      */
     namespace Hotkeys {
         /**
@@ -7338,7 +7693,7 @@ export declare namespace IOConnectDesktop {
      * In other cases, you may want to present the user with several options for executing an action or handling data from the current app.
      * The Intents API makes all that possible by enabling apps to register, find and raise Intents.
      *
-     * The Intents API is accessible through the `io.intents` object.
+     * The Intents API is accessible via the [`io.intents`](#API) object.
      */
     namespace Intents {
         /**
@@ -7875,7 +8230,7 @@ export declare namespace IOConnectDesktop {
      * The Notifications API allows you to raise notifications, handle notification and action clicks via Interop methods,
      * control the Notification Panel and subscribe for notification events.
      *
-     * The Notifications API is accessible through the `io.notifications` object.
+     * The Notifications API is accessible via the [`io.notifications`](#API) object.
      */
     export namespace Notifications {
         /**
@@ -8507,7 +8862,7 @@ export declare namespace IOConnectDesktop {
      * **io.Connect Desktop** has two built-in themes - **Day** and **Night**.
      * You can control the themes programmatically by using the Themes API.
      *
-     * The Themes API is accessible through the `io.themes` object.
+     * The Themes API is accessible via the [`io.themes`](#API) object.
      */
     export namespace Themes {
         /**
@@ -8562,7 +8917,7 @@ export declare namespace IOConnectDesktop {
      * The App Preferences API provides methods for updating, replacing and clearing user settings stored for the current or a specific app,
      * as well as for all apps of the current user.
      *
-     * The App Preferences API is accessible through the `io.prefs` object.
+     * The App Preferences API is accessible via the [`io.prefs`](#API) object.
      */
     export namespace Preferences {
 
@@ -8738,7 +9093,7 @@ export declare namespace IOConnectDesktop {
      * The Cookies API enables your web app to manage cookies. You can get a list of cookies by applying a filter
      * that will be matched against all cookies, and also set and modify cookies, or remove cookies by name and URL.
      *
-     * The Cookies API is accessible through the `io.cookies` object.
+     * The Cookies API is accessible via the [`io.cookies`](#API) object.
      */
     export namespace Cookies {
         /**
@@ -8921,19 +9276,24 @@ export declare namespace IOConnectDesktop {
      *
      * For an app to be able to register interception handlers, interception must be enabled in the system configuration of **io.Connect Desktop**.
      *
+     * The Interception API is accessible via the [`io.interception`](#API) object.
+     *
      * *Available since io.Connect Desktop 9.6.*
      */
     export namespace Interception {
+
         /**
          * Interception API.
          * @since io.Connect Desktop 9.6
          */
         export interface API {
+
             /**
              * Registers an interception handler. It's possible to register only a single interception handler per platform operation within an API domain.
              * @param config Object containing the interception handler to register and settings describing the platform operations to intercept.
              */
             register(config: InterceptionRegistrationConfig): Promise<void>;
+
             /**
              * Unregisters all interception handlers for the specified platform operations.
              * @param config Object specifying the platform operations which to stop intercepting.
@@ -8945,12 +9305,14 @@ export declare namespace IOConnectDesktop {
          * Settings for registering an interception handler for the targeted platform operations.
          */
         export interface InterceptionRegistrationConfig {
+
             /**
              * Method implementation to be registered as a handler for the specified platform operations.
              * It's possible to register only a single interception handler per platform operation within an API domain.
              * @param message Object describing the intercepted platform operation.
              */
             handler: (message: InterceptionMessage) => Promise<InterceptionResponse | void>;
+
             /**
              * List of objects each describing a platform operation to intercept.
              */
@@ -8961,6 +9323,7 @@ export declare namespace IOConnectDesktop {
          * Settings for unregistering the interception handlers for the targeted platform operations.
          */
         export interface InterceptionUnregistrationConfig {
+
             /**
              * List of objects each describing a platform operation which to stop intercepting.
              */
@@ -8971,22 +9334,27 @@ export declare namespace IOConnectDesktop {
          * Describes an intercepted platform operation.
          */
         export interface InterceptionMessage {
+
             /**
              * The io.Connect API domain in which the platform operation has been intercepted.
              */
             domain: string;
+
             /**
              * The io.Connect platform operation that has been intercepted.
              */
             operation: string;
+
             /**
              * ID of the app that has invoked the platform operation. Can be used for tracking purposes.
              */
             callerId: string;
+
             /**
              * Specifies whether the platform operation has been intercepted before or after the execution of its default implementation.
              */
             phase: "before" | "after";
+
             /**
              * In the `"before"` phase, this property will contain the arguments with which the calling app has invoked the intercepted operation.
              * In the `"after"` phase, this property will contain the result returned from executing the default platform implementation of the intercepted operation
@@ -9003,11 +9371,13 @@ export declare namespace IOConnectDesktop {
          * the platform will return the already calculated result.
          */
         export interface InterceptionResponse {
+
             /**
              * Arguments with which to proceed the execution of the intercepted platform operation.
              * This property is taken into account only when the platform operation is intercepted before the execution of its default implementation.
              */
             operationArgs?: any[];
+
             /**
              * Result from the platform operation. Use this property to return a result from your interception handler
              * when the platform operation has been intercepted after the execution of its default implementation.
@@ -9021,15 +9391,18 @@ export declare namespace IOConnectDesktop {
          * Describes a platform operation to intercept and provides settings for its interception.
          */
         export interface Interception {
+
             /**
              * io.Connect API domain of the platform operation.
              */
             domain: string | "all";
+
             /**
              * Name of the io.Connect platform operation within the specified io.Connect API domain.
              * Set to `"all"` to intercept all operations within the domain.
              */
             operation: string | "all";
+
             /**
              * Specifies whether to intercept the platform operation before or after the execution of its default implementation.
              * Set to `"all"` to intercept the platform operation both before and after the execution of its default implementation.