@openfin/fdc3-api 41.103.2 → 41.103.10

package/out/fdc3-api.d.ts

@@ -85,6 +85,12 @@ declare type AlertRequestedEvent = BaseEvent_5 & {
     url: string;
 };
 
+declare type AnalyticsOnlyCalls = 'layout-get-stack-by-view' | 'layout-add-view' | 'layout-close-view' | `layout-controller-${string}`;
+
+declare type AnalyticsProtocolMap = {
+    [k in AnalyticsOnlyCalls]: VoidCall;
+};
+
 declare type AnchorType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
 declare type AnyStrategy = ChannelStrategy<any>;
@@ -1705,6 +1711,7 @@ declare type BaseConfig = {
     devToolsPort?: number;
     installerUI?: boolean;
     runtime?: RuntimeConfig;
+    apiDiagnostics?: boolean;
     appAssets?: [
         {
         src: string;
@@ -2824,7 +2831,7 @@ declare class ChannelProvider extends ChannelBase {
      * a read-only array containing all the identities of connecting clients.
      */
     get connections(): OpenFin.ClientConnectionPayload[];
-    static handleClientDisconnection(channel: ChannelProvider, payload: any): void;
+    static handleClientDisconnection(channel: ChannelProvider, payload: ClientDisconnectionPayload): void;
     static setProviderRemoval(provider: ChannelProvider, remove: Function): void;
     /**
      * @internal
@@ -3086,6 +3093,11 @@ declare type ClearCacheOption = {
      * browser data that can be used across sessions
      */
     localStorage?: boolean;
+    /**
+     * Clears saved window-state data written for windows that use `saveWindowState`.
+     * After this data is cleared, previously persisted bounds and state (Maximized/Minimized) will not be restored until new state is written again.
+     */
+    windowState?: boolean;
 };
 
 /**
@@ -3106,6 +3118,10 @@ declare type ClickedMenuResult<Data extends unknown = unknown> = {
  */
 declare type ClientConnectionPayload = ClientIdentity & ClientInfo;
 
+declare type ClientDisconnectionPayload = OpenFin.Identity & {
+    endpointId?: string;
+};
+
 /**
  * Identity of a channel client. Includes endpointId to differentiate between different connections for an entity.
  * @interface
@@ -3311,6 +3327,7 @@ declare type ClipboardApiPermissions = {
     writeRtf: boolean;
     readRtf: boolean;
     write: boolean;
+    setClipboard: boolean;
 };
 
 /**
@@ -4834,20 +4851,11 @@ declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventType exten
         type: EventType;
     }>, ...args: any[]) => boolean;
     private hasEmitter;
-    /**
-     * Cleans up after removal of a listener, e.g. deleting any lingering deregistration handlers for a
-     * `once` subscription.
-     *
-     * @remarks Implementing this as a `removeListener` handler ensures that direct removal of a listener
-     * on the base emitter will not leak additional core handlers.  We could do this in the forwarding method,
-     * which would involve less "magic," but would be more-vulnerable to accidental re-introduction of a leak.
-     */
-    private cleanUpRemovedListener;
     private getOrCreateEmitter;
     listeners: (type: string | symbol) => Function[];
     listenerCount: (type: string | symbol) => number;
     protected registerEventListener: (eventType: EmitterEventType, options: OpenFin.SubscriptionOptions | undefined, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
-    protected deregisterEventListener: (eventType: EmitterEventType, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
+    private deregisterEventListener;
     /**
      * Adds a listener to the end of the listeners array for the specified event.
      *
@@ -4883,7 +4891,7 @@ declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventType exten
      * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
      */
     removeListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    protected deregisterAllListeners(eventType: EmitterEventType): Promise<EventEmitter | void>;
+    private deregisterAllListeners;
     /**
      * Removes all listeners, or those of the specified event.
      *
@@ -5332,6 +5340,19 @@ declare type ExtensionsInstallFailedEvent = ExtensionsEvent & {
     type: 'extensions-install-failed';
 };
 
+/**
+ * these api calls are not implemented in the javscript api, only in the external adapter
+ * If they don't exist in the external adapter they should be removed.
+ */
+declare type ExternalAdapterOnlyCalls = 'subscriber-added' | 'subscriber-removed' | 'clipboard-clear' | 'create-proxy-socket' | 'authenticate-proxy-socket' | 'convert-options' | 'generate-guid' | 'get-config' | 'get-remote-config' | 'get-nearest-display-root' | 'get-preload-scripts' | 'raise-event' | 'set-window-preload-state' | 'dock-window' | 'get-current-window-options' | 'redirect-window-to-url' | 'request-new-content' | 'raise-many-events' | 'show-menu' | 'resolve-proxy' | 'undock-window' | 'window-embedded' | 'window-get-cached-bounds' | 'resource-fetch-authenticate' | 'set-cookie';
+
+declare type ExternalAdapterOnlyCallsMap = {
+    [k in ExternalAdapterOnlyCalls]: {
+        request: any;
+        response: any;
+    };
+};
+
 /**
  * An ExternalApplication object representing native language adapter connections to the runtime. Allows
  * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.
@@ -6821,6 +6842,16 @@ declare type IntentMetadata<TargetType = any> = {
  */
 declare class InterApplicationBus extends Base {
     Channel: Channel;
+    /**
+     * Event types for the InterApplicationBus.
+     *
+     * @remarks The `subscriber-added` and `subscriber-removed` events are disabled by default.
+     * To re-enable them, launch the runtime with the `--emit-legacy-iab-events` flag.
+     * These events will be removed in a future version. Use {@link Channel} for connection
+     * lifecycle management instead.
+     *
+     * @deprecated Use {@link Channel} `onConnection` / `onDisconnection` instead.
+     */
     events: {
         subscriberAdded: string;
         subscriberRemoved: string;
@@ -9858,11 +9889,11 @@ declare type MutableWindowOptions = {
      */
     customData: any;
     /**
-     * @deprecated Will be removed in runtime version 45
-     * @defaultValue true
-     *
      * Show the window's frame.
      *
+     * @remarks
+     * This property will not be updatable starting runtime version 45.
+     *
      * @default true
      */
     frame: boolean;
@@ -10203,6 +10234,8 @@ declare namespace OpenFin {
         TabStack,
         _Window as Window,
         _WindowModule,
+        Clipboard_2 as Clipboard,
+        InterApplicationBus,
         InteropClient,
         InteropBroker,
         InteropModule,
@@ -12882,7 +12915,7 @@ declare type PropagatedWindowEvent<TargetTopic extends string> = PropagatedEvent
  */
 declare type PropagatedWindowEventType = PropagatedEvent_3<string>['type'];
 
-declare interface ProtocolMap extends ProtocolMapBase {
+declare type ProtocolMap = ExternalAdapterOnlyCallsMap & AnalyticsProtocolMap & {
     'is-application-running': ApplicationIdentityCall<{}, boolean>;
     'destroy-application': ApplicationIdentityCall<{
         force: boolean;
@@ -12949,8 +12982,15 @@ declare interface ProtocolMap extends ProtocolMapBase {
             downloadLocation: string;
         };
         response: void;
+        secure: true;
+        namespace: 'Application';
+        apiPath: '.setFileDownloadLocation';
+    };
+    'get-file-download-location': ApplicationIdentityCall<{}, string> & {
+        secure: true;
+        namespace: 'Application';
+        apiPath: '.getFileDownloadLocation';
     };
-    'get-file-download-location': ApplicationIdentityCall<{}, string>;
     'show-tray-icon-popup-menu': {
         request: OpenFin.Identity & {
             options: OpenFin.ShowTrayIconPopupMenuOptions;
@@ -12958,19 +12998,17 @@ declare interface ProtocolMap extends ProtocolMapBase {
         response: OpenFin.MenuResult;
     };
     'close-tray-icon-popup-menu': IdentityCall<{}, void>;
-    'wrap-application': VoidCall;
-    'wrap-application-sync': VoidCall;
     'create-application': ApiCall<OpenFin.ApplicationCreationOptions, void>;
-    'application-create': VoidCall;
-    'start-application': VoidCall;
     'run-applications': ApiCall<{
         applications: Array<OpenFin.ManifestInfo>;
         opts?: OpenFin.RvmLaunchOptions;
     }, void>;
-    'get-current-application': VoidCall;
-    'get-current-application-sync': VoidCall;
-    'application-start-from-manifest': VoidCall;
-    'application-create-from-manifest': VoidCall;
+    'send-analytics-batch': {
+        request: {
+            counts: Record<string, number>;
+        };
+        response: void;
+    };
     'request-external-authorization': {
         request: any;
         response: void;
@@ -12990,44 +13028,69 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'clipboard-read-image': {
         request: OpenFin.ReadImageClipboardRequest;
         response: string;
+        apiPath: '.readImage';
+        namespace: 'Clipboard';
     };
     'clipboard-read-text': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        apiPath: '.readText';
+        namespace: 'Clipboard';
     };
     'clipboard-read-html': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        apiPath: '.readHtml';
+        namespace: 'Clipboard';
     };
     'clipboard-read-rtf': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        apiPath: '.readRtf';
+        namespace: 'Clipboard';
     };
     'clipboard-write-image': {
         request: OpenFin.WriteImageClipboardRequest;
         response: void;
+        apiPath: '.writeImage';
+        namespace: 'Clipboard';
     };
     'clipboard-write': {
         request: OpenFin.WriteAnyRequestType;
         response: void;
+        apiPath: '.write';
+        namespace: 'Clipboard';
     };
     'clipboard-write-text': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        apiPath: '.writeText';
+        namespace: 'Clipboard';
+        foo: '';
+    };
+    'set-clipboard': {
+        request: OpenFin.WriteClipboardRequest;
+        response: void;
+        apiPath: '.setClipboard';
+        namespace: 'Clipboard';
     };
     'clipboard-write-html': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        apiPath: '.writeHtml';
+        namespace: 'Clipboard';
     };
     'clipboard-write-rtf': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        apiPath: '.writeRtf';
+        namespace: 'Clipboard';
     };
     'get-view-window': IdentityCall<{}, OpenFin.Identity>;
     'create-view': IdentityCall<OpenFin.ViewCreationOptions & {
@@ -13054,18 +13117,10 @@ declare interface ProtocolMap extends ProtocolMapBase {
         options: OpenFin.UpdatableViewOptions;
     }>;
     'trigger-before-unload': IdentityCall<{}, boolean>;
-    'view-wrap-sync': VoidCall;
-    'view-wrap': VoidCall;
-    'view-get-current': VoidCall;
-    'view-get-current-sync': VoidCall;
     'animate-window': IdentityCall<{
         transitions: OpenFin.Transition;
         options: OpenFin.TransitionOptions;
     }>;
-    'activate-window-and-focus': ApiCall<{
-        winIdentity: OpenFin.Identity;
-        focusIdentity: OpenFin.Identity;
-    }, boolean>;
     'get-all-frames': IdentityCall<{}, OpenFin.FrameInfo[]>;
     'get-window-bounds': IdentityCall<{
         options?: OpenFin.GetBoundsOptions;
@@ -13154,15 +13209,13 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'create-window': VoidCall;
     'get-current-window': VoidCall;
     'get-current-window-sync': VoidCall;
+    'activate-window-and-focus': ApiCall<{
+        winIdentity: OpenFin.Identity;
+        focusIdentity: OpenFin.Identity;
+    }, boolean>;
     'get-external-application-info': ApiCall<OpenFin.ApplicationIdentity, OpenFin.ExternalApplicationInfo>;
-    'external-application-wrap': VoidCall;
-    'external-application-wrap-sync': VoidCall;
     'get-frame-info': ApiCall<OpenFin.Identity, OpenFin.FrameInfo>;
     'get-parent-window': ApiCall<OpenFin.Identity, OpenFin.FrameInfo>;
-    'frame-wrap': VoidCall;
-    'frame-wrap-sync': VoidCall;
-    'frame-get-current': VoidCall;
-    'frame-get-current-sync': VoidCall;
     'global-hotkey-register': {
         request: {
             hotkey: string;
@@ -13246,6 +13299,10 @@ declare interface ProtocolMap extends ProtocolMapBase {
         request: any;
         response: any;
     };
+    'send-channel-result': {
+        request: any;
+        response: any;
+    };
     'get-version': GetterCall<string>;
     'clear-cache': ApiCall<OpenFin.ClearCacheOption, void>;
     'delete-cache-request': VoidCall;
@@ -13295,7 +13352,11 @@ declare interface ProtocolMap extends ProtocolMapBase {
         action: string;
         runtimes: string[];
     }>;
-    'get-installed-apps': GetterCall<OpenFin.InstalledApps>;
+    'get-installed-apps': GetterCall<OpenFin.InstalledApps> & {
+        secure: true;
+        apiPath: '.getInstalledApps';
+        namespace: 'System';
+    };
     'view-log': ApiCall<OpenFin.GetLogRequestType, string>;
     'get-machine-id': GetterCall<string>;
     'get-min-log-level': GetterCall<OpenFin.LogLevel>;
@@ -13308,8 +13369,16 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'get-runtime-info': GetterCall<OpenFin.RuntimeInfo>;
     'get-rvm-info': GetterCall<OpenFin.RVMInfo>;
     'get-host-specs': GetterCall<OpenFin.HostSpecs>;
-    'get-os-info': GetterCall<OpenFin.OSInfo>;
-    'launch-external-process': ApiCall<OpenFin.ExternalProcessRequestType, OpenFin.Identity>;
+    'get-os-info': GetterCall<OpenFin.OSInfo> & {
+        secure: true;
+        apiPath: '.getOSInfo';
+        namespace: 'System';
+    };
+    'launch-external-process': ApiCall<OpenFin.ExternalProcessRequestType, OpenFin.Identity> & {
+        secure: true;
+        apiPath: '.launchExternalProcess';
+        namespace: 'System';
+    };
     'monitor-external-process': ApiCall<OpenFin.ExternalProcessInfo, OpenFin.Identity>;
     'write-to-log': ApiCall<{
         level: string;
@@ -13317,25 +13386,48 @@ declare interface ProtocolMap extends ProtocolMapBase {
     }, void>;
     'open-url-with-browser': ApiCall<{
         url: string;
-    }, void>;
-    'register-custom-protocol': ApiCall<OpenFin.CustomProtocolOptions, void>;
+    }, void> & {
+        secure: true;
+        apiPath: '.openUrlWithBrowser';
+        namespace: 'System';
+    };
+    'register-custom-protocol': ApiCall<OpenFin.CustomProtocolOptions, void> & {
+        secure: true;
+        apiPath: '.registerCustomProtocol';
+        namespace: 'System';
+    };
     'unregister-custom-protocol': ApiCall<{
         protocolName: string;
-    }, void>;
+    }, void> & {
+        secure: true;
+        apiPath: '.unregisterCustomProtocol';
+        namespace: 'System';
+    };
     'get-custom-protocol-state': ApiCall<{
         protocolName: string;
-    }, OpenFin.CustomProtocolState>;
+    }, OpenFin.CustomProtocolState> & {
+        secure: true;
+        apiPath: '.getCustomProtocolState';
+        namespace: 'System';
+    };
     'release-external-process': ApiCall<{
         uuid: string;
     }, void>;
     'show-developer-tools': ApiCall<OpenFin.Identity, void>;
-    'terminate-external-process': ApiCall<OpenFin.TerminateExternalRequestType, void>;
+    'terminate-external-process': ApiCall<OpenFin.TerminateExternalRequestType, void> & {
+        secure: true;
+        apiPath: '.terminateExternalProcess';
+        namespace: 'System';
+    };
     'update-proxy': ApiCall<OpenFin.ProxyConfig, void>;
     'download-asset': {
         request: OpenFin.AppAssetInfo & {
             downloadId: string;
         };
         response: void;
+        secure: true;
+        apiPath: '.downloadAsset';
+        namespace: 'System';
     };
     'download-runtime': {
         request: OpenFin.RuntimeDownloadOptions & {
@@ -13364,7 +13456,11 @@ declare interface ProtocolMap extends ProtocolMapBase {
         rootKey: string;
         subkey: string;
         value: string;
-    }, OpenFin.RegistryInfo>;
+    }, OpenFin.RegistryInfo> & {
+        secure: true;
+        apiPath: '.readRegistryValue';
+        namespace: 'System';
+    };
     'register-external-connection': ApiCall<{
         uuid: string;
     }, OpenFin.ExternalConnection>;
@@ -13398,26 +13494,48 @@ declare interface ProtocolMap extends ProtocolMapBase {
             permissions: any;
         };
         response: OpenFin.NativeWindowIntegrationProviderAuthorization;
+        secure: true;
+        apiPath: '.enableNativeWindowIntegrationProvider';
+        namespace: 'System';
     };
     'register-usage': ApiCall<OpenFin.RegisterUsageData, void>;
     'system-get-printers': GetterCall<OpenFin.PrinterInfo[]>;
     'system-update-process-logging-options': ApiCall<{
         options: OpenFin.ProcessLoggingOptions;
     }, void>;
-    'get-domain-settings': ApiCall<void, OpenFin.DomainSettings>;
+    'get-domain-settings': ApiCall<void, OpenFin.DomainSettings> & {
+        secure: true;
+        apiPath: '.getDomainSettings';
+        namespace: 'System';
+    };
     'serve-asset': ApiCall<{
         options: OpenFin.ServeAssetOptions;
-    }, OpenFin.ServedAssetInfo>;
+    }, OpenFin.ServedAssetInfo> & {
+        secure: true;
+        apiPath: '.serveAsset';
+        namespace: 'System';
+    };
     'set-domain-settings': ApiCall<{
         domainSettings: OpenFin.DomainSettings;
-    }, void>;
+    }, void> & {
+        secure: true;
+        apiPath: '.setDomainSettings';
+        namespace: 'System';
+    };
     'get-current-domain-settings': ApiCall<{
         identity: OpenFin.Identity;
-    }, OpenFin.ResolvedDomainSettings>;
+    }, OpenFin.ResolvedDomainSettings> & {
+        secure: true;
+        apiPath: '.getCurrentDomainSettings';
+        namespace: 'System';
+    };
     'resolve-domain-settings': ApiCall<{
         url: string;
-    }, OpenFin.ResolvedDomainSettings>;
-    'system-register-shutdown-handler': VoidCall;
+    }, OpenFin.ResolvedDomainSettings> & {
+        secure: true;
+        apiPath: '.resolveDomainSettings';
+        namespace: 'System';
+    };
     'get-permissions': GetterCall<any>;
     'refresh-extensions': {
         request: void;
@@ -13427,24 +13545,6 @@ declare interface ProtocolMap extends ProtocolMapBase {
         request: void;
         response: OpenFin.ExtensionInfo[];
     };
-    'fdc3-add-context-listener': VoidCall;
-    'fdc3-add-intent-listener': VoidCall;
-    'fdc3-raise-intent': VoidCall;
-    'fdc3-find-intent': VoidCall;
-    'fdc3-find-intents-by-context': VoidCall;
-    'fdc3-raise-intent-for-context': VoidCall;
-    'fdc3-get-info': VoidCall;
-    'fdc3-find-instances': VoidCall;
-    'fdc3-get-app-metadata': VoidCall;
-    'fdc3-broadcast': VoidCall;
-    'fdc3-open': VoidCall;
-    'fdc3-get-or-create-channel': VoidCall;
-    'fdc3-get-system-channels': VoidCall;
-    'fdc3-join-channel': VoidCall;
-    'fdc3-get-current-channel': VoidCall;
-    'fdc3-leave-current-channel': VoidCall;
-    'interop-init': VoidCall;
-    'interop-connect-sync': VoidCall;
     'interop-client-set-context': VoidCall;
     'interop-client-add-context-handler': VoidCall;
     'interop-client-get-context-groups': VoidCall;
@@ -13475,12 +13575,6 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'interop-session-context-group-set-context': VoidCall;
     'interop-session-context-group-get-context': VoidCall;
     'interop-session-context-group-add-handler': VoidCall;
-    'platform-wrap': VoidCall;
-    'platform-wrap-sync': VoidCall;
-    'platform-get-current': VoidCall;
-    'platform-get-current-sync': VoidCall;
-    'platform-start': VoidCall;
-    'platform-start-from-manifest': VoidCall;
     'platform-get-client': ApplicationIdentityCall<{}, void>;
     'platform-create-view': ApplicationIdentityCall<{}, void>;
     'platform-create-window': ApplicationIdentityCall<{}, void>;
@@ -13493,11 +13587,6 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'platform-set-window-context': ApplicationIdentityCall<{}, void>;
     'platform-get-window-context': ApplicationIdentityCall<{}, void>;
     'platform-close-window': ApplicationIdentityCall<{}, void>;
-    'layout-wrap': VoidCall;
-    'layout-wrap-sync': VoidCall;
-    'layout-get-current': VoidCall;
-    'layout-get-current-sync': VoidCall;
-    'layout-init': VoidCall;
     'layout-get-config': VoidCall;
     'layout-get-views': VoidCall;
     'layout-replace': VoidCall;
@@ -13516,12 +13605,6 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'layout-controller-create-adjacent-stack': VoidCall;
     'layout-controller-get-adjacent-stacks': VoidCall;
     'layout-controller-set-stack-active-view': VoidCall;
-    'snapshot-source-init': VoidCall;
-    'snapshot-source-wrap-sync': VoidCall;
-    'snapshot-source-wrap': VoidCall;
-    'snapshot-source-ready': VoidCall;
-    'snapshot-source-get-snapshot': VoidCall;
-    'snapshot-source-apply-snapshot': VoidCall;
     'capture-page': IdentityCall<{
         options?: OpenFin.CapturePageOptions;
     }, string>;
@@ -13602,15 +13685,27 @@ declare interface ProtocolMap extends ProtocolMapBase {
         };
         response: void;
     };
-}
-
-declare interface ProtocolMapBase {
-    [action: string]: {
-        request: any;
-        response: any;
-        specialResponse?: any;
+    'subscribe-to-desktop-event': {
+        request: {
+            topic: string;
+            type: string;
+            uuid?: string;
+            name?: string;
+            timestamp?: number;
+        };
+        response: void;
     };
-}
+    'unsubscribe-to-desktop-event': {
+        request: {
+            topic: string;
+            type: string;
+            uuid?: string;
+            name?: string;
+            timestamp?: number;
+        };
+        response: void;
+    };
+};
 
 declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
 
@@ -14176,7 +14271,9 @@ declare type SecurityRealmEvent = BaseEvent_9 & {
 
 declare type SendActionResponse<T extends keyof ProtocolMap> = Message<{
     data: ProtocolMap[T]['response'];
-} & ProtocolMap[T]['specialResponse']>;
+} & (ProtocolMap[T] extends {
+    specialResponse: infer U;
+} ? U : {})>;
 
 /**
  * @interface
@@ -14691,13 +14788,15 @@ declare class System extends EmitterBase<OpenFin.SystemEvent> {
      * * cookies: browser [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)
      * * localStorage: browser data that can be used across sessions ([local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage))
      * * appcache: html5 [application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)
+     * * windowState: clears data written for windows using `saveWindowState`; after clearing, previously saved bounds and state will not be restored until new state is written
      * @example
      * ```js
      * const clearCacheOptions = {
      *     appcache: true,
      *     cache: true,
      *     cookies: true,
-     *     localStorage: true
+     *     localStorage: true,
+     *     windowState: true
      * };
      * fin.System.clearCache(clearCacheOptions).then(() => console.log('Cache cleared')).catch(err => console.log(err));
      * ```
@@ -16195,7 +16294,6 @@ declare type SystemEventType = EventType_8;
  */
 declare type SystemPermissions = {
     getOSInfo: boolean;
-    getAllExternalWindows: boolean;
     setDomainSettings: boolean;
     getDomainSettings: boolean;
     getCurrentDomainSettings: boolean;
@@ -16235,6 +16333,10 @@ declare type SystemPermissions = {
         enabled: boolean;
         protocols: string[];
     };
+    getInstalledApps: boolean;
+    downloadAsset: boolean;
+    serveAsset: boolean;
+    enableNativeWindowIntegrationProvider: boolean;
 };
 
 /**
@@ -16543,9 +16645,12 @@ declare class Transport<MeType extends EntityType = EntityType> extends EventEmi
     sendRaw: Wire['send'];
     eventAggregator: EventAggregator;
     protected messageHandlers: MessageHandler[];
-    constructor(factory: WireFactory, environment: Environment, config: OpenFin.Identity);
+    constructor(factory: WireFactory, environment: Environment, config: OpenFin.Identity & {
+        apiDiagnostics?: boolean;
+    });
     getFin(): OpenFin.Fin<MeType>;
     registerFin(_fin: OpenFin.Fin<MeType>): void;
+    recordAnalytic(action: string): void;
     connectSync: () => void;
     getPort: () => string;
     shutdown(): Promise<void>;
@@ -16553,7 +16658,7 @@ declare class Transport<MeType extends EntityType = EntityType> extends EventEmi
     private connectRemote;
     connectByPort(config: ExistingConnectConfig): Promise<void>;
     private authorize;
-    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): SentMessage<SendActionResponse<T>>;
+    sendAction<T extends keyof ProtocolMap>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): SentMessage<SendActionResponse<T>>;
     protected nackHandler(payloadOrMessage: RuntimeErrorPayload | string, reject: Function, callSites?: NodeJS.CallSite[]): void;
     ferryAction(origData: any): Promise<Message<any>>;
     registerMessageHandler(handler: MessageHandler): void;