@openfin/fdc3-api 42.100.80 → 42.100.82

package/out/fdc3-api-alpha.d.ts

@@ -85,6 +85,12 @@ declare type AlertRequestedEvent = BaseEvent_5 & {
     url: string;
 };
 
+declare type AnalyticsOnlyCalls = 'window-get-web-window' | 'layout-get-by-view-identity' | 'layout-get-stack-by-view' | 'layout-add-view' | 'layout-close-view' | 'view-get-parent-layout' | 'view-get-current-stack' | 'window-is-main-window' | 'window-get-parent-application' | 'window-get-parent-window' | 'window-create-window' | 'window-get-layout' | 'window-dispatch-popup-result' | `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>;
@@ -3250,6 +3256,7 @@ declare type ClipboardApiPermissions = {
     writeRtf: boolean;
     readRtf: boolean;
     write: boolean;
+    setClipboard: boolean;
 };
 
 /**
@@ -5212,6 +5219,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}.
@@ -9829,6 +9849,8 @@ declare namespace OpenFin {
         TabStack,
         _Window as Window,
         _WindowModule,
+        Clipboard_2 as Clipboard,
+        InterApplicationBus,
         InteropClient,
         InteropBroker,
         InteropModule,
@@ -11855,6 +11877,10 @@ declare interface PlatformProvider {
      * @returns A promise resolving to `true` if the window should prevent the app from quitting, otherwise `false`.
      */
     shouldWindowPreventQuit(windowIdentity: OpenFin.Identity): Promise<boolean>;
+    /**
+     * Method that is called every time an error occurs when processing an action in the Platform Provider. It is meant to be overriden, as a means to debug Platform applications
+     */
+    onError(action: string, error: Error, callerIdentity: OpenFin.Identity): void;
 }
 
 /**
@@ -12421,7 +12447,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;
@@ -12488,8 +12514,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;
@@ -12529,44 +12562,79 @@ declare interface ProtocolMap extends ProtocolMapBase {
     'clipboard-read-image': {
         request: OpenFin.ReadImageClipboardRequest;
         response: string;
+        secure: true;
+        apiPath: '.readImage';
+        namespace: 'Clipboard';
     };
     'clipboard-read-text': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        secure: true;
+        apiPath: '.readText';
+        namespace: 'Clipboard';
     };
     'clipboard-read-html': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        secure: true;
+        apiPath: '.readHtml';
+        namespace: 'Clipboard';
     };
     'clipboard-read-rtf': {
         request: {
             type?: OpenFin.ClipboardSelectionType;
         };
         response: string;
+        secure: true;
+        apiPath: '.readRtf';
+        namespace: 'Clipboard';
     };
     'clipboard-write-image': {
         request: OpenFin.WriteImageClipboardRequest;
         response: void;
+        secure: true;
+        apiPath: '.writeImage';
+        namespace: 'Clipboard';
     };
     'clipboard-write': {
         request: OpenFin.WriteAnyRequestType;
         response: void;
+        secure: true;
+        apiPath: '.write';
+        namespace: 'Clipboard';
     };
     'clipboard-write-text': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        secure: true;
+        apiPath: '.writeText';
+        namespace: 'Clipboard';
+        foo: '';
+    };
+    'set-clipboard': {
+        request: OpenFin.WriteClipboardRequest;
+        response: void;
+        secure: true;
+        apiPath: '.setClipboard';
+        namespace: 'Clipboard';
     };
     'clipboard-write-html': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        secure: true;
+        apiPath: '.writeHtml';
+        namespace: 'Clipboard';
     };
     'clipboard-write-rtf': {
         request: OpenFin.WriteClipboardRequest;
         response: void;
+        secure: true;
+        apiPath: '.writeRtf';
+        namespace: 'Clipboard';
     };
     'get-view-window': IdentityCall<{}, OpenFin.Identity>;
     'create-view': IdentityCall<OpenFin.ViewCreationOptions & {
@@ -12781,6 +12849,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;
@@ -12830,7 +12902,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>;
@@ -12843,8 +12919,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;
@@ -12852,25 +12936,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 & {
@@ -12899,7 +13006,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>;
@@ -12933,25 +13044,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>;
+    }, OpenFin.ResolvedDomainSettings> & {
+        secure: true;
+        apiPath: '.resolveDomainSettings';
+        namespace: 'System';
+    };
     'system-register-shutdown-handler': VoidCall;
     'get-permissions': GetterCall<any>;
     'refresh-extensions': {
@@ -13137,15 +13271,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;
 
@@ -13711,7 +13857,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
@@ -15724,7 +15872,6 @@ declare type SystemEventType = EventType_8;
  */
 declare type SystemPermissions = {
     getOSInfo: boolean;
-    getAllExternalWindows: boolean;
     setDomainSettings: boolean;
     getDomainSettings: boolean;
     getCurrentDomainSettings: boolean;
@@ -15764,6 +15911,10 @@ declare type SystemPermissions = {
         enabled: boolean;
         protocols: string[];
     };
+    getInstalledApps: boolean;
+    downloadAsset: boolean;
+    serveAsset: boolean;
+    enableNativeWindowIntegrationProvider: boolean;
 };
 
 /**
@@ -16075,7 +16226,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;