@openfin/core 29.72.12 → 29.72.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "29.72.12",
+    "version": "29.72.14",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/api/base.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import Transport from '../transport/transport';
 import Fin from './fin';
@@ -11,6 +12,7 @@ export declare class Base {
     get me(): Identity;
     protected isNodeEnvironment: () => boolean;
     protected isOpenFinEnvironment: () => boolean;
+    protected isBrowserEnvironment: () => boolean;
 }
 export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
     #private;
@@ -25,14 +27,14 @@ export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
     listenerCount: (type: string | symbol) => number;
     protected registerEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
     protected deregisterEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
-    on: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    on<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
     addListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    once: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    prependListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    prependOnceListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    removeListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    protected deregisterAllListeners: (eventType: Extract<keyof EventTypes, string> | string | symbol) => Promise<EventEmitter | void>;
-    removeAllListeners: (eventType?: Extract<keyof EventTypes, string> | string | symbol) => Promise<this>;
+    once<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependOnceListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    removeListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    protected deregisterAllListeners(eventType: Extract<keyof EventTypes, string> | string | symbol): Promise<EventEmitter | void>;
+    removeAllListeners(eventType?: Extract<keyof EventTypes, string> | string | symbol): Promise<this>;
     private deleteEmitterIfNothingRegistered;
 }
 export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {

package/src/api/base.js

@@ -25,6 +25,9 @@ class Base {
         this.isOpenFinEnvironment = () => {
             return this.wire.environment.constructor.name === 'OpenFinEnvironment';
         };
+        this.isBrowserEnvironment = () => {
+            return this.wire.environment.constructor.name === 'BrowserEnvironment';
+        };
         this.wire = wire;
     }
     get fin() {
@@ -83,86 +86,86 @@ class EmitterBase extends Base {
             // This will only be reached if unsubscribe from event that does not exist but do not want to error here
             return Promise.resolve();
         };
-        this.on = async (eventType, listener, options) => {
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.on(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
         this.addListener = this.on;
-        this.once = async (eventType, listener, options) => {
-            const deregister = () => this.deregisterEventListener(eventType);
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.once(eventType, deregister);
-                emitter.once(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, deregister);
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
-        this.prependListener = async (eventType, listener, options) => {
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.prependListener(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
-        this.prependOnceListener = async (eventType, listener, options) => {
-            const deregister = () => this.deregisterEventListener(eventType);
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.prependOnceListener(eventType, listener);
-                emitter.once(eventType, deregister);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-                emitter.removeListener(eventType, deregister);
-            });
-            return this;
-        };
-        this.removeListener = async (eventType, listener, options) => {
-            const emitter = await this.deregisterEventListener(eventType, options);
+        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
+        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+    }
+    async on(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.on(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    async once(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.once(eventType, deregister);
+            emitter.once(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, deregister);
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    async prependListener(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependListener(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    async prependOnceListener(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependOnceListener(eventType, listener);
+            emitter.once(eventType, deregister);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+            emitter.removeListener(eventType, deregister);
+        });
+        return this;
+    }
+    async removeListener(eventType, listener, options) {
+        const emitter = await this.deregisterEventListener(eventType, options);
+        if (emitter) {
+            emitter.removeListener(eventType, listener);
+            this.deleteEmitterIfNothingRegistered(emitter);
+        }
+        return this;
+    }
+    async deregisterAllListeners(eventType) {
+        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
+        if (this.hasEmitter()) {
+            const emitter = this.getOrCreateEmitter();
+            const refCount = emitter.listenerCount(runtimeEvent.type);
+            const unsubscribePromises = [];
+            for (let i = 0; i < refCount; i++) {
+                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
+            }
+            await Promise.all(unsubscribePromises);
+            return emitter;
+        }
+        return undefined;
+    }
+    async removeAllListeners(eventType) {
+        const removeByEvent = async (event) => {
+            const emitter = await this.deregisterAllListeners(event);
             if (emitter) {
-                emitter.removeListener(eventType, listener);
+                emitter.removeAllListeners(event);
                 this.deleteEmitterIfNothingRegistered(emitter);
             }
-            return this;
-        };
-        this.deregisterAllListeners = async (eventType) => {
-            const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
-            if (this.hasEmitter()) {
-                const emitter = this.getOrCreateEmitter();
-                const refCount = emitter.listenerCount(runtimeEvent.type);
-                const unsubscribePromises = [];
-                for (let i = 0; i < refCount; i++) {
-                    unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
-                }
-                await Promise.all(unsubscribePromises);
-                return emitter;
-            }
-            return undefined;
         };
-        this.removeAllListeners = async (eventType) => {
-            const removeByEvent = async (event) => {
-                const emitter = await this.deregisterAllListeners(event);
-                if (emitter) {
-                    emitter.removeAllListeners(event);
-                    this.deleteEmitterIfNothingRegistered(emitter);
-                }
-            };
-            if (eventType) {
-                await removeByEvent(eventType);
-            }
-            else if (this.hasEmitter()) {
-                const events = this.getOrCreateEmitter().eventNames();
-                await promises_1.promiseMap(events, removeByEvent);
-            }
-            return this;
-        };
-        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
-        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+        if (eventType) {
+            await removeByEvent(eventType);
+        }
+        else if (this.hasEmitter()) {
+            const events = this.getOrCreateEmitter().eventNames();
+            await promises_1.promiseMap(events, removeByEvent);
+        }
+        return this;
     }
     deleteEmitterIfNothingRegistered(emitter) {
         if (emitter.eventNames().length === 0) {

package/src/api/interop/InteropBroker.d.ts

@@ -326,14 +326,58 @@ export declare class InteropBroker extends Base {
      * Responsible for resolving an fdc3.open call.
      * Must be overridden.
      * @param { Fdc3OpenOptions } fdc3OpenOptions fdc3.open options
-     * @param { clientIdentity } clientIdentity Identity of the Client making the request.
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
      */
     fdc3HandleOpen({ app, context }: {
-        app: FDC3.TargetApp;
+        app: FDC3.TargetApp | FDC3v2.AppIdentifier;
         context: OpenFin.Context;
-    }, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<void | FDC3v2.AppIdentifier>;
+    /**
+     * Responsible for resolving the fdc3.findInstances call.
+     * Must be overridden
+     * @param { AppIdentifier(2) }  app AppIdentifier that was passed to fdc3.findInstances
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
+     */
     fdc3HandleFindInstances(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * Responsible for resolving the fdc3.getAppMetadata call.
+     * Must be overridden
+     * @param { AppIdentifier(2) } app AppIdentifier that was passed to fdc3.getAppMetadata
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
+     */
     fdc3HandleGetAppMetadata(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * This function is called by the Interop Broker whenever a Context handler would fire.
+     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+     * part of the Context object. Then would you need to call
+     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId
+     * @param { ClientIdentity } clientIdentity
+     * @param { string } handlerId
+     * @param { Context } context
+     * @returns { Promise<void> }
+     * @tutorial interopBroker.invokeContextHandler
+     */
+    invokeContextHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, context: OpenFin.Context): Promise<void>;
+    /**
+     * This function is called by the Interop Broker whenever an Intent handler would fire.
+     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+     * part of the Context object inside the Intent object. Then would you need to call
+     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId
+     * @param { ClientIdentity } ClientIdentity
+     * @param { string } handlerId
+     * @param { Context } context
+     * @returns { Promise<void> }
+     * @tutorial interopBroker.invokeIntentHandler
+     */
+    invokeIntentHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, intent: OpenFin.Intent): Promise<void>;
+    /**
+     * Responsible for resolving fdc3.getInfo for FDC3 2.0
+     * Would need to return the optionalFeatures and appMetadata for the {@link ImplementationMetadata ImplementationMetadata}.
+     * Must be overridden.
+     * @param clientIdentity
+     * @returns { Promise<ImplementationMetadata(2)> }
+     */
+    fdc3HandleGetInfo(clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     decorateSnapshot(snapshot: OpenFin.Snapshot): OpenFin.Snapshot;
     applySnapshot(snapshot: OpenFin.Snapshot, options: OpenFin.ApplySnapshotOptions): void;
     updateExistingClients(contextGroupStates: OpenFin.ContextGroupStates): void;
@@ -344,7 +388,6 @@ export declare class InteropBroker extends Base {
         handlerId: string;
     }, clientIdentity: OpenFin.ClientIdentity): void;
     intentHandlerRegistered(payload: any, clientIdentity: OpenFin.ClientIdentity): Promise<void>;
-    protected invokeContextHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, context: OpenFin.Context): void;
     removeContextHandler({ handlerId }: {
         handlerId: string;
     }, clientIdentity: OpenFin.ClientIdentity): void;

package/src/api/interop/InteropBroker.js

@@ -549,7 +549,7 @@ class InteropBroker extends base_1.Base {
                     const { clientIdentity, pendingIntents } = handlerInfo;
                     try {
                         const intentToSend = pendingIntents[pendingIntents.length - 1];
-                        await this.channel.dispatch(clientIdentity, handlerId, intentToSend);
+                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
                         handlerInfo.pendingIntents = [];
                     }
                     catch (error) {
@@ -620,7 +620,7 @@ class InteropBroker extends base_1.Base {
      * Responsible for resolving an fdc3.open call.
      * Must be overridden.
      * @param { Fdc3OpenOptions } fdc3OpenOptions fdc3.open options
-     * @param { clientIdentity } clientIdentity Identity of the Client making the request.
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
      */
     // eslint-disable-next-line class-methods-use-this
     async fdc3HandleOpen({ app, context }, clientIdentity) {
@@ -628,17 +628,77 @@ class InteropBroker extends base_1.Base {
         console.warn(warning);
         throw new Error(utils_1.BROKER_ERRORS.fdc3Open);
     }
+    /**
+     * Responsible for resolving the fdc3.findInstances call.
+     * Must be overridden
+     * @param { AppIdentifier(2) }  app AppIdentifier that was passed to fdc3.findInstances
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
+     */
     // eslint-disable-next-line class-methods-use-this
     async fdc3HandleFindInstances(app, clientIdentity) {
         const warning = utils_1.generateOverrideWarning('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);
         console.warn(warning);
         throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
     }
+    /**
+     * Responsible for resolving the fdc3.getAppMetadata call.
+     * Must be overridden
+     * @param { AppIdentifier(2) } app AppIdentifier that was passed to fdc3.getAppMetadata
+     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
+     */
     // eslint-disable-next-line class-methods-use-this
     async fdc3HandleGetAppMetadata(app, clientIdentity) {
         const warning = utils_1.generateOverrideWarning('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);
         console.warn(warning);
-        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
+        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);
+    }
+    /**
+     * This function is called by the Interop Broker whenever a Context handler would fire.
+     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+     * part of the Context object. Then would you need to call
+     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId
+     * @param { ClientIdentity } clientIdentity
+     * @param { string } handlerId
+     * @param { Context } context
+     * @returns { Promise<void> }
+     * @tutorial interopBroker.invokeContextHandler
+     */
+    async invokeContextHandler(clientIdentity, handlerId, context) {
+        const provider = await this.getProvider();
+        try {
+            await provider.dispatch(clientIdentity, handlerId, context);
+        }
+        catch (error) {
+            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);
+        }
+    }
+    /**
+     * This function is called by the Interop Broker whenever an Intent handler would fire.
+     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+     * part of the Context object inside the Intent object. Then would you need to call
+     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId
+     * @param { ClientIdentity } ClientIdentity
+     * @param { string } handlerId
+     * @param { Context } context
+     * @returns { Promise<void> }
+     * @tutorial interopBroker.invokeIntentHandler
+     */
+    async invokeIntentHandler(clientIdentity, handlerId, intent) {
+        const provider = await this.getProvider();
+        await provider.dispatch(clientIdentity, handlerId, intent);
+    }
+    /**
+     * Responsible for resolving fdc3.getInfo for FDC3 2.0
+     * Would need to return the optionalFeatures and appMetadata for the {@link ImplementationMetadata ImplementationMetadata}.
+     * Must be overridden.
+     * @param clientIdentity
+     * @returns { Promise<ImplementationMetadata(2)> }
+     */
+    // eslint-disable-next-line class-methods-use-this
+    async fdc3HandleGetInfo(clientIdentity) {
+        const warning = utils_1.generateOverrideWarning('fdc3.getInfo', 'InteropBroker.fdc3GetInfo', clientIdentity);
+        console.warn(warning);
+        throw new Error(utils_1.BROKER_ERRORS.fdc3GetInfo);
     }
     /*
     Snapshot APIs
@@ -743,7 +803,7 @@ class InteropBroker extends base_1.Base {
             try {
                 if (pendingIntents.length > 0) {
                     const intentToSend = pendingIntents[pendingIntents.length - 1];
-                    await this.channel.dispatch(clientIdentity, handlerId, intentToSend);
+                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
                     handlerInfo.pendingIntents = [];
                 }
             }
@@ -752,14 +812,6 @@ class InteropBroker extends base_1.Base {
             }
         }
     }
-    // Used to invoke a client's context handler
-    invokeContextHandler(clientIdentity, handlerId, context) {
-        this.getProvider().then((channel) => {
-            channel.dispatch(clientIdentity, handlerId, context).catch((e) => {
-                console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, e);
-            });
-        });
-    }
     // Used to remove a context handler for a client
     removeContextHandler({ handlerId }, clientIdentity) {
         const clientState = this.getClientState(clientIdentity);
@@ -951,6 +1003,9 @@ class InteropBroker extends base_1.Base {
         channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
         channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));
         channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));
+        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {
+            return this.fdc3HandleGetInfo.bind(this)(clientIdentity);
+        });
     }
     /**
      * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.

package/src/api/interop/InteropClient.d.ts

@@ -272,5 +272,5 @@ export declare class InteropClient extends Base {
      * @tutorial interop.onDisconnection
      */
     onDisconnection(listener: OpenFin.InteropClientOnDisconnectionListener): Promise<void>;
-    static ferryFdc3Call(interopClient: OpenFin.InteropClient, action: string, payload: any): Promise<any>;
+    static ferryFdc3Call(interopClient: OpenFin.InteropClient, action: string, payload?: any): Promise<any>;
 }

package/src/api/interop/InteropClient.js

@@ -453,7 +453,7 @@ class InteropClient extends base_1.Base {
     // used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker
     static async ferryFdc3Call(interopClient, action, payload) {
         const client = await __classPrivateFieldGet(interopClient, _clientPromise);
-        return client.dispatch(action, payload);
+        return client.dispatch(action, payload || null);
     }
 }
 exports.InteropClient = InteropClient;

package/src/api/interop/fdc3/fdc3-1.2.d.ts

@@ -51,12 +51,16 @@ import { Base } from '../../base';
  * @property { string } [providerVersion] The provider runtime version
  */
 /**
- * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * @class
+ * @alias fdc3
+ * @version 1.2
+ * @hideconstructor
+ * @desc The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
  * while using our Interop API under the hood. In order to use this set of APIs
  * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
  * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
  *
- * We currently support APIs based on FDC3 1.2. To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
  * property to its options:
  *
  * ```js
@@ -83,10 +87,6 @@ import { Base } from '../../base';
  *    window.addEventListener('fdc3Ready', fdc3Action);
  * }
  * ```
- *
- * @class
- * @alias Fdc3
- * @hideconstructor
  */
 export default class Fdc3Module extends Base implements FDC3.DesktopAgent {
     /**

package/src/api/interop/fdc3/fdc3-1.2.js

@@ -56,12 +56,16 @@ const InteropClient_1 = require("../InteropClient");
  * @property { string } [providerVersion] The provider runtime version
  */
 /**
- * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * @class
+ * @alias fdc3
+ * @version 1.2
+ * @hideconstructor
+ * @desc The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
  * while using our Interop API under the hood. In order to use this set of APIs
  * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
  * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
  *
- * We currently support APIs based on FDC3 1.2. To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
  * property to its options:
  *
  * ```js
@@ -88,10 +92,6 @@ const InteropClient_1 = require("../InteropClient");
  *    window.addEventListener('fdc3Ready', fdc3Action);
  * }
  * ```
- *
- * @class
- * @alias Fdc3
- * @hideconstructor
  */
 class Fdc3Module extends base_1.Base {
     /**