@openfin/fdc3-api 40.105.1 → 40.105.4

package/out/fdc3-api.js

@@ -10,7 +10,7 @@ var utils$2 = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;
+	exports.checkContextIntegrity = exports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;
 	const generateId = () => `${Math.random()}${Date.now()}`;
 	exports.generateId = generateId;
 	const wrapInTryCatch = (f, prefix) => (...args) => {
@@ -68,7 +68,45 @@ var utils$2 = {};
 	        }
 	    };
 	};
-	exports.wrapIntentHandler = wrapIntentHandler; 
+	exports.wrapIntentHandler = wrapIntentHandler;
+	const checkContextIntegrity = (context) => {
+	    if (!context) {
+	        return { isValid: false, reason: 'No context supplied' };
+	    }
+	    if (typeof context !== 'object') {
+	        return { isValid: false, reason: 'Context must be an Object' };
+	    }
+	    if (!context.type) {
+	        return { isValid: false, reason: 'Context must have a type property' };
+	    }
+	    if (context.id && typeof context.id !== 'object') {
+	        return {
+	            isValid: false,
+	            reason: 'Context id must be an Object populated with key-value identifiers (if set)'
+	        };
+	    }
+	    if (context.id) {
+	        const { id } = context;
+	        const keys = Object.keys(id);
+	        let foundBadIdentifier = false;
+	        if (!keys.length) {
+	            return { isValid: false, reason: 'Context id must have at least one key-value identifier' };
+	        }
+	        keys.forEach((key) => {
+	            if (typeof key !== 'string' || typeof id[key] !== 'string') {
+	                foundBadIdentifier = true;
+	            }
+	        });
+	        if (foundBadIdentifier) {
+	            return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };
+	        }
+	    }
+	    if (context.name && typeof context.name !== 'string') {
+	        return { isValid: false, reason: 'Context name must be of string type (if set)' };
+	    }
+	    return { isValid: true };
+	};
+	exports.checkContextIntegrity = checkContextIntegrity; 
 } (utils$2));
 
 var fdc3Common = {};
@@ -438,7 +476,7 @@ PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
 	exports.getIntentResolution = getIntentResolution; 
 } (utils$1));
 
-var InteropClient = {};
+var InteropClient$1 = {};
 
 var base = {};
 
@@ -471,13 +509,13 @@ async function promiseMapSerial(arr, func) {
 }
 promises.promiseMapSerial = promiseMapSerial;
 
-var __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -562,7 +600,7 @@ class EmitterBase extends Base {
         this.emit = (eventType, payload, ...args) => {
             return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
         };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$1(this, _EmitterBase_emitterAccessor, "f"));
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$3(this, _EmitterBase_emitterAccessor, "f"));
         /**
          * Cleans up after removal of a listener, e.g. deleting any lingering deregistration handlers for a
          * `once` subscription.
@@ -572,14 +610,14 @@ class EmitterBase extends Base {
          * which would involve less "magic," but would be more-vulnerable to accidental re-introduction of a leak.
          */
         this.cleanUpRemovedListener = (eventType, listener) => {
-            const deregister = __classPrivateFieldGet$1(this, _EmitterBase_deregisterOnceListeners, "f").get(listener);
+            const deregister = __classPrivateFieldGet$3(this, _EmitterBase_deregisterOnceListeners, "f").get(listener);
             if (deregister) {
-                const emitter = this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$1(this, _EmitterBase_emitterAccessor, "f"));
+                const emitter = this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$3(this, _EmitterBase_emitterAccessor, "f"));
                 emitter.removeListener(eventType, deregister);
             }
         };
         this.getOrCreateEmitter = () => {
-            const emitter = this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$1(this, _EmitterBase_emitterAccessor, "f"));
+            const emitter = this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$3(this, _EmitterBase_emitterAccessor, "f"));
             if (!emitter.listeners('removeListener').includes(this.cleanUpRemovedListener)) {
                 emitter.on('removeListener', this.cleanUpRemovedListener);
             }
@@ -621,8 +659,8 @@ 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();
         };
-        __classPrivateFieldSet$1(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
-        __classPrivateFieldSet$1(this, _EmitterBase_deregisterOnceListeners, new WeakMap(), "f");
+        __classPrivateFieldSet$3(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
+        __classPrivateFieldSet$3(this, _EmitterBase_deregisterOnceListeners, new WeakMap(), "f");
         this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
     }
     /**
@@ -651,7 +689,7 @@ class EmitterBase extends Base {
      */
     async once(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
-        __classPrivateFieldGet$1(this, _EmitterBase_deregisterOnceListeners, "f").set(listener, deregister);
+        __classPrivateFieldGet$3(this, _EmitterBase_deregisterOnceListeners, "f").set(listener, deregister);
         await this.registerEventListener(eventType, options, (emitter) => {
             emitter.once(eventType, deregister);
             emitter.once(eventType, listener);
@@ -682,7 +720,7 @@ class EmitterBase extends Base {
      */
     async prependOnceListener(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
-        __classPrivateFieldGet$1(this, _EmitterBase_deregisterOnceListeners, "f").set(listener, deregister);
+        __classPrivateFieldGet$3(this, _EmitterBase_deregisterOnceListeners, "f").set(listener, deregister);
         await this.registerEventListener(eventType, options, (emitter) => {
             emitter.prependOnceListener(eventType, listener);
             emitter.once(eventType, deregister);
@@ -742,7 +780,7 @@ class EmitterBase extends Base {
     }
     deleteEmitterIfNothingRegistered(emitter) {
         if (emitter.eventNames().every((type) => type === 'removeListener')) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet$1(this, _EmitterBase_emitterAccessor, "f"));
+            this.wire.eventAggregator.delete(__classPrivateFieldGet$3(this, _EmitterBase_emitterAccessor, "f"));
         }
     }
 }
@@ -754,27 +792,27 @@ base.Reply = Reply;
 
 var SessionContextGroupClient$1 = {};
 
-var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SessionContextGroupClient_clientPromise;
 Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
-const base_1 = base;
-const utils_1 = utils$2;
-class SessionContextGroupClient extends base_1.Base {
+const base_1$1 = base;
+const utils_1$4 = utils$2;
+class SessionContextGroupClient extends base_1$1.Base {
     constructor(wire, client, id) {
         super(wire);
         _SessionContextGroupClient_clientPromise.set(this, void 0);
         this.id = id;
-        __classPrivateFieldSet(this, _SessionContextGroupClient_clientPromise, client, "f");
+        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, "f");
     }
     /**
      * Sets a context for the session context group.
@@ -786,7 +824,7 @@ class SessionContextGroupClient extends base_1.Base {
         this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
             sessionContextGroupId: this.id,
             context
@@ -796,7 +834,7 @@ class SessionContextGroupClient extends base_1.Base {
         this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
             sessionContextGroupId: this.id,
             type
@@ -809,20 +847,20 @@ class SessionContextGroupClient extends base_1.Base {
         if (typeof contextHandler !== 'function') {
             throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
         }
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         let handlerId;
         if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1.generateId)()}`;
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$4.generateId)()}`;
         }
         else {
             handlerId = `sessionContextHandler:invoke-${this.id}`;
         }
-        client.register(handlerId, (0, utils_1.wrapContextHandler)(contextHandler, handlerId));
+        client.register(handlerId, (0, utils_1$4.wrapContextHandler)(contextHandler, handlerId));
         await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
         return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
     }
     async createUnsubscribeCb(handlerId) {
-        const client = await __classPrivateFieldGet(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return async () => {
             client.remove(handlerId);
             await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
@@ -831,1443 +869,1406 @@ class SessionContextGroupClient extends base_1.Base {
     getUserInstance() {
         return {
             id: this.id,
-            setContext: (0, utils_1.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
-            getCurrentContext: (0, utils_1.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
-            addContextHandler: (0, utils_1.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
+            setContext: (0, utils_1$4.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: (0, utils_1$4.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: (0, utils_1$4.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
         };
     }
 }
 SessionContextGroupClient$1.default = SessionContextGroupClient;
 _SessionContextGroupClient_clientPromise = new WeakMap();
 
-var fdc32_0 = {};
-
-var hasRequiredFdc32_0;
+var __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _InteropClient_clientPromise, _InteropClient_sessionContextGroups, _InteropClient_fdc3Factory;
+Object.defineProperty(InteropClient$1, "__esModule", { value: true });
+InteropClient$1.InteropClient = void 0;
+const base_1 = base;
+const SessionContextGroupClient_1 = __importDefault$1(SessionContextGroupClient$1);
+const utils_1$3 = utils$2;
+/**
+ * The Interop Client API is broken up into two groups:
+ *
+ * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
+ *
+ * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
+ *
+ * ---
+ *
+ * All APIs are available at the `fin.me.interop` namespace.
+ *
+ * ---
+ *
+ * **You only need 2 things to participate in Interop Context Grouping:**
+ * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+ * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
+ *
+ * ---
+ *
+ * ##### Constructor
+ * Returned by {@link Interop.connectSync Interop.connectSync}.
+ *
+ * ---
+ *
+ * ##### Interop methods intended for Views
+ *
+ *
+ * **Context Groups API**
+ *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+ *  * {@link InteropClient#setContext setContext(context)}
+ *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
+ *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
+ *
+ *
+ * **Intents API**
+ *  * {@link InteropClient#fireIntent fireIntent(intent)}
+ *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
+ *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
+ *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
+ *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
+ *
+ * ##### Interop methods intended for Windows
+ *  * {@link InteropClient#getContextGroups getContextGroups()}
+ *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
+ *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
+ *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
+ *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
+ *
+ */
+class InteropClient extends base_1.Base {
+    /**
+     * @internal
+     */
+    constructor(wire, clientPromise, fdc3Factory) {
+        super(wire);
+        _InteropClient_clientPromise.set(this, void 0);
+        _InteropClient_sessionContextGroups.set(this, void 0);
+        _InteropClient_fdc3Factory.set(this, void 0);
+        __classPrivateFieldSet$1(this, _InteropClient_sessionContextGroups, new Map(), "f");
+        __classPrivateFieldSet$1(this, _InteropClient_clientPromise, clientPromise, "f");
+        __classPrivateFieldSet$1(this, _InteropClient_fdc3Factory, fdc3Factory, "f");
+    }
+    /*
+    Client APIs
+    */
+    /**
+     * Sets a context for the context group of the current entity.
+     *
+     * @remarks The entity must be part of a context group in order set a context.
+     *
+     * @param context - New context to set.
+     *
+     * @example
+     * ```js
+     * setInstrumentContext = async (ticker) => {
+     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})
+     * }
+     *
+     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument
+     * instrumentElement.on('click', (evt) => {
+     *     setInstrumentContext(evt.ticker)
+     * })
+     * ```
+     */
+    async setContext(context) {
+        this.wire.sendAction('interop-client-set-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('setContext', { context });
+    }
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,
+     * it will receive all of its declared contexts.
+     *
+     * @param handler - Handler for incoming context.
+     * @param contextType - The type of context you wish to handle.
+     *
+     * @example
+     * ```js
+     * function handleIncomingContext(contextInfo) {
+     *     const { type, id } = contextInfo;
+     *     switch (type) {
+     *         case 'instrument':
+     *             handleInstrumentContext(contextInfo);
+     *             break;
+     *         case 'country':
+     *             handleCountryContext(contextInfo);
+     *             break;
+     *
+     *         default:
+     *             break;
+     *     }
+     * }
+     *
+     *
+     * function handleInstrumentContext(contextInfo) {
+     *     const { type, id } = contextInfo;
+     *     console.log('contextInfo for instrument', contextInfo)
+     * }
+     *
+     * function handleCountryContext(contextInfo) {
+     *     const { type, id } = contextInfo;
+     *     console.log('contextInfo for country', contextInfo)
+     * }
+     *
+     * fin.me.interop.addContextHandler(handleIncomingContext);
+     * ```
+     *
+     *
+     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.
+     *
+     * ```js
+     * function handleInstrumentContext(contextInfo) {
+     *     const { type, id } = contextInfo;
+     *     console.log('contextInfo for instrument', contextInfo)
+     * }
+     *
+     * function handleCountryContext(contextInfo) {
+     *     const { type, id } = contextInfo;
+     *     console.log('contextInfo for country', contextInfo)
+     * }
+     *
+     *
+     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')
+     * fin.me.interop.addContextHandler(handleCountryContext, 'country')
+     * ```
+     */
+    async addContextHandler(handler, contextType) {
+        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        if (typeof handler !== 'function') {
+            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        let handlerId;
+        if (contextType) {
+            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1$3.generateId)()}`;
+        }
+        else {
+            handlerId = 'invokeContextHandler';
+        }
+        const wrappedHandler = (0, utils_1$3.wrapContextHandler)(handler, handlerId);
+        client.register(handlerId, wrappedHandler);
+        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
+        return {
+            unsubscribe: async () => {
+                client.remove(handlerId);
+                await client.dispatch('removeContextHandler', { handlerId });
+            }
+        };
+    }
+    /*
+    Platform Window APIs
+    */
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     * Used by Platform Windows.
+     *
+     * @example
+     * ```js
+     * fin.me.interop.getContextGroups()
+     *         .then(contextGroups => {
+     *             contextGroups.forEach(contextGroup => {
+     *                 console.log(contextGroup.displayMetadata.name)
+     *                 console.log(contextGroup.displayMetadata.color)
+     *             })
+     *         })
+     * ```
+     */
+    async getContextGroups() {
+        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('getContextGroups');
+    }
+    /**
+     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+     * If no target is specified, it adds the sender to the context group.
+     *
+     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
+     * Used by Platform Windows.
+     *
+     * @param contextGroupId - Id of the context group.
+     * @param target - Identity of the entity you wish to join to a context group.
+     *
+     * @example
+     * ```js
+     * joinViewToContextGroup = async (contextGroupId, view) => {
+     *     await fin.me.interop.joinContextGroup(contextGroupId, view);
+     * }
+     *
+     * getLastFocusedView()
+     *     .then(lastFocusedViewIdentity => {
+     *         joinViewToContextGroup('red', lastFocusedViewIdentity)
+     *     })
+     * ```
+     */
+    async joinContextGroup(contextGroupId, target) {
+        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for joinContextGroup.');
+        }
+        return client.dispatch('joinContextGroup', { contextGroupId, target });
+    }
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     * Used by Platform Windows.
+     *
+     * @param target - Identity of the entity you wish to join to a context group.
+     *
+     * @example
+     * ```js
+     * removeViewFromContextGroup = async (view) => {
+     *     await fin.me.interop.removeFromContextGroup(view);
+     * }
+     *
+     * getLastFocusedView()
+     *     .then(lastFocusedViewIdentity => {
+     *         removeViewFromContextGroup(lastFocusedViewIdentity)
+     *     })
+     * ```
+     */
+    async removeFromContextGroup(target) {
+        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('removeFromContextGroup', { target });
+    }
+    /**
+     * Gets all clients for a context group.
+     *
+     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
+     *
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     * @param contextGroupId - The id of context group you wish to get clients for.
+     *
+     * @example
+     * ```js
+     * fin.me.interop.getAllClientsInContextGroup('red')
+     *     .then(clientsInContextGroup => {
+     *         console.log(clientsInContextGroup)
+     *     })
+     * ```
+     */
+    async getAllClientsInContextGroup(contextGroupId) {
+        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
+        }
+        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
+    }
+    /**
+     * Gets display info for a context group
+     *
+     * @remarks Used by Platform Windows.
+     * @param contextGroupId - The id of context group you wish to get display info for.
+     *
+     * @example
+     * ```js
+     * fin.me.interop.getInfoForContextGroup('red')
+     *     .then(contextGroupInfo => {
+     *         console.log(contextGroupInfo.displayMetadata.name)
+     *         console.log(contextGroupInfo.displayMetadata.color)
+     *     })
+     * ```
+     */
+    async getInfoForContextGroup(contextGroupId) {
+        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        if (!contextGroupId) {
+            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
+        }
+        return client.dispatch('getInfoForContextGroup', { contextGroupId });
+    }
+    /**
+     * Sends an intent to the Interop Broker to resolve.
+     * @param intent - The combination of an action and a context that is passed to an application for resolution.
+     *
+     * @example
+     * ```js
+     * // View wants to fire an Intent after a user clicks on a ticker
+     * tickerElement.on('click', (element) => {
+     *     const ticker = element.innerText;
+     *     const intent = {
+     *         name: 'ViewChart',
+     *         context: {type: 'fdc3.instrument', id: { ticker }}
+     *     }
+     *
+     *     fin.me.interop.fireIntent(intent);
+     * })
+     * ```
+     */
+    async fireIntent(intent) {
+        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
+            // don't expose, this is only for api analytics purposes
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('fireIntent', intent);
+    }
+    /**
+     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
+     * @param handler - Registered function meant to handle a specific intent type.
+     * @param intentName - The name of an intent.
+     *
+     * @example
+     * ```js
+     * const intentHandler = (intent) => {
+     *     const { context } = intent;
+     *     myViewChartHandler(context);
+     * };
+     *
+     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');
+     *
+     * function myAppCloseSequence() {
+     *     // to unsubscribe the handler, simply call:
+     *     subscription.unsubscribe();
+     * }
+     * ```
+     */
+    async registerIntentHandler(handler, intentName, options) {
+        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
+            // don't expose, this is only for api analytics purposes
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        const handlerId = `intent-handler-${intentName}`;
+        const wrappedHandler = (0, utils_1$3.wrapIntentHandler)(handler, handlerId);
+        try {
+            await client.register(handlerId, wrappedHandler);
+            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
+        }
+        catch (error) {
+            throw new Error('Unable to register intent handler');
+        }
+        return {
+            unsubscribe: async () => {
+                client.remove(handlerId);
+            }
+        };
+    }
+    /**
+     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
+     * last context of that type.
+     * @param contextType
+     *
+     * @example
+     * ```js
+     * await fin.me.interop.joinContextGroup('yellow');
+     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+     * const currentContext = await fin.me.interop.getCurrentContext();
+     *
+     * // with a specific context
+     * await fin.me.interop.joinContextGroup('yellow');
+     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});
+     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+     * const currentContext = await fin.me.interop.getCurrentContext('country');
+     * ```
+     */
+    async getCurrentContext(contextType) {
+        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('getCurrentContext', { contextType });
+    }
+    /**
+     * Get information for a particular Intent from the Interop Broker.
+     *
+     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.
+     * The format for the response will be determined by the App Provider overriding the function.
+     *
+     * @param options
+     *
+     * @example
+     * ```js
+     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');
+     * ```
+     */
+    async getInfoForIntent(options) {
+        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('getInfoForIntent', options);
+    }
+    /**
+     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
+     *
+     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.
+     * The format for the response will be determined by the App Provider overriding the function.
+     *
+     * @param context
+     *
+     * @example
+     * ```js
+     * tickerElement.on('click', (element) => {
+     *     const ticker = element.innerText;
+     *
+     *     const context = {
+     *         type: 'fdc3.instrument',
+     *         id: {
+     *             ticker
+     *         }
+     *     }
+     *
+     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);
+     * })
+     * ```
+     */
+    async getInfoForIntentsByContext(context) {
+        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('getInfoForIntentsByContext', context);
+    }
+    /**
+     * Sends a Context that will be resolved to an Intent by the Interop Broker.
+     * This context accepts a metadata property.
+     *
+     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.
+     * The format for the response will be determined by the App Provider overriding the function.
+     *
+     * @param context
+     *
+     * @example
+     * ```js
+     * tickerElement.on('click', (element) => {
+     *     const ticker = element.innerText;
+     *
+     *     const context = {
+     *         type: 'fdc3.instrument',
+     *         id: {
+     *             ticker
+     *         }
+     *     }
+     *
+     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);
+     * })
+     * ```
+     */
+    async fireIntentForContext(context) {
+        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.dispatch('fireIntentForContext', context);
+    }
+    /**
+     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
+     * If the sessionContextGroup doesn't exist, one will get created.
+     *
+     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.
+     * @param sessionContextGroupId - Id of the context group.
+     *
+     * @example
+     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:
+     *
+     * My color-picker View:
+     * ```js
+     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+     *
+     *     const myColorPickerElement = document.getElementById('color-palette-picker');
+     *     myColorPickerElement.addEventListener('change', event => {
+     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });
+     *     });
+     * ```
+     *
+     * In other views:
+     * ```js
+     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+     *
+     *     const changeColorPalette = ({ selection }) => {
+     *         // change the color palette to the selection
+     *     };
+     *
+     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.
+     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');
+     * ```
+     */
+    async joinSessionContextGroup(sessionContextGroupId) {
+        try {
+            const currentSessionContextGroup = __classPrivateFieldGet$1(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
+            if (currentSessionContextGroup) {
+                return currentSessionContextGroup.getUserInstance();
+            }
+            const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
+                sessionContextGroupId
+            });
+            if (hasConflict) {
+                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
+            }
+            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
+            __classPrivateFieldGet$1(this, _InteropClient_sessionContextGroups, "f").set(sessionContextGroupId, newSessionContextGroup);
+            return newSessionContextGroup.getUserInstance();
+        }
+        catch (error) {
+            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.
+     * Only one listener per Interop Client can be set.
+     * @param listener
+     *
+     * @example
+     * ```js
+     * const listener = (event) => {
+     *     const { type, topic, brokerName} = event;
+     *     console.log(`Disconnected from Interop Broker ${brokerName} `);
+     * }
+     *
+     * await fin.me.interop.onDisconnection(listener);
+     * ```
+     */
+    async onDisconnection(listener) {
+        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _InteropClient_clientPromise, "f");
+        return client.onDisconnection((event) => {
+            const { uuid } = event;
+            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });
+        });
+    }
+    getFDC3Sync(version) {
+        return __classPrivateFieldGet$1(this, _InteropClient_fdc3Factory, "f").call(this, version, this, this.wire);
+    }
+    async getFDC3(version) {
+        return this.getFDC3Sync(version);
+    }
+    /**
+     * @internal
+     *
+     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker
+     */
+    static async ferryFdc3Call(interopClient, action, payload) {
+        const client = await __classPrivateFieldGet$1(interopClient, _InteropClient_clientPromise, "f");
+        return client.dispatch(action, payload || null);
+    }
+}
+InteropClient$1.InteropClient = InteropClient;
+_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap(), _InteropClient_fdc3Factory = new WeakMap();
 
-function requireFdc32_0 () {
-	if (hasRequiredFdc32_0) return fdc32_0;
-	hasRequiredFdc32_0 = 1;
-	Object.defineProperty(fdc32_0, "__esModule", { value: true });
-	fdc32_0.Fdc3Module2 = void 0;
-	const fdc3_common_1 = requireFdc3Common();
-	const utils_1 = utils$2;
-	const InteropClient_1 = requireInteropClient();
-	const utils_2 = utils$1;
-	const PrivateChannelClient_1 = PrivateChannelClient$1;
-	/**
-	 * @version 2.0
-	 * 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-context-sharing Interop API}.
-	 *
-	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
-	 * property to its options:
-	 *
-	 * ```js
-	 * {
-	 *     autoShow: false,
-	 *     saveWindowState: true,
-	 *     url: 'https://openfin.co',
-	 *     fdc3InteropApi: '2.0'
-	 * }
-	 * ```
-	 *
-	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
-	 *
-	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
-	 *
-	 * ```js
-	 * function fdc3Action() {
-	 *     // Make some fdc3 API calls here
-	 * }
-	 *
-	 * if (window.fdc3) {
-	 *    fdc3Action();
-	 * } else {
-	 *    window.addEventListener('fdc3Ready', fdc3Action);
-	 * }
-	 * ```
-	 */
-	class Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {
-	    /**
-	     * Launches an app, specified via an AppIdentifier object.
-	     * @param app
-	     * @param context
-	     *
-	     * @tutorial fdc3.open
-	     */
-	    async open(app, context) {
-	        if (typeof app === 'string') {
-	            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
-	        }
-	        // eslint-disable-next-line no-underscore-dangle
-	        return super._open(app, context);
-	    }
-	    /**
-	     * Find all the available instances for a particular application.
-	     * @param app
-	     *
-	     * @tutorial fdc3v2.findInstances
-	     */
-	    async findInstances(app) {
-	        this.wire.sendAction('fdc3-find-instances').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
-	     * @param app
-	     *
-	     * @tutorial fdc3v2.getAppMetadata
-	     */
-	    async getAppMetadata(app) {
-	        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
-	     * @param contextType
-	     * @param handler
-	     *
-	     * @tutorial fdc3.addContextListener
-	     */
-	    // @ts-expect-error TODO [CORE-1524]
-	    async addContextListener(contextType, handler) {
-	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler
-	        // here so it only gets passed these parameters
-	        const getWrappedHandler = (handlerToWrap) => {
-	            return (context) => {
-	                const { contextMetadata, ...rest } = context;
-	                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];
-	                handlerToWrap(...args);
-	            };
-	        };
-	        let actualHandler = handler;
-	        let wrappedHandler = getWrappedHandler(actualHandler);
-	        if (typeof contextType === 'function') {
-	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
-	            actualHandler = contextType;
-	            wrappedHandler = getWrappedHandler(actualHandler);
-	            return this.client.addContextHandler(wrappedHandler);
-	        }
-	        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);
-	    }
-	    /**
-	     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.
-	     * @param intent Name of the Intent
-	     * @param context Context
-	     * @param resultType The type of result returned for any intent specified during resolution.
-	     *
-	     * @tutorial fdc3.findIntent
-	     */
-	    async findIntent(intent, context, resultType) {
-	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Find all the available intents for a particular context.
-	     * @param context
-	     * @param resultType The type of result returned for any intent specified during resolution.
-	     *
-	     * @tutorial fdc3v2.findIntentsByContext
-	     */
-	    async findIntentsByContext(context, resultType) {
-	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const payload = resultType ? { context, metadata: { resultType } } : context;
-	        try {
-	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Raises a specific intent for resolution against apps registered with the desktop agent.
-	     * @param intent Name of the Intent
-	     * @param context Context associated with the Intent
-	     * @param app
-	     *
-	     * @tutorial fdc3v2.raiseIntent
-	     */
-	    async raiseIntent(intent, context, app) {
-	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            if (typeof app === 'string') {
-	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
-	            }
-	            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
-	     * @param context Context associated with the Intent
-	     * @param app
-	     *
-	     * @tutorial fdc3v2.raiseIntentForContext
-	     */
-	    async raiseIntentForContext(context, app) {
-	        // TODO: We have to do the same thing we do for raiseIntent here as well.
-	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            if (typeof app === 'string') {
-	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
-	            }
-	            return (0, utils_2.getIntentResolution)(this.client, context, app);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Adds a listener for incoming intents.
-	     * @param intent  Name of the Intent
-	     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.
-	     *
-	     * @tutorial fdc3.addIntentListener
-	     */
-	    async addIntentListener(intent, handler) {
-	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        if (typeof intent !== 'string') {
-	            throw new Error('First argument must be an Intent name');
-	        }
-	        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
-	        // so we wrap it here and only pass those paramaters.
-	        const contextHandler = async (raisedIntent) => {
-	            let intentResult;
-	            let intentResultToSend;
-	            const { context, metadata: intentMetadata } = raisedIntent;
-	            const { contextMetadata, metadata, ...rest } = context;
-	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
-	            try {
-	                const newContext = metadata ? { metadata, ...rest } : { ...rest };
-	                intentResult = await handler(newContext, contextMetadata);
-	                intentResultToSend = intentResult;
-	            }
-	            catch (error) {
-	                intentResult = error;
-	                intentResultToSend = { error: true };
-	            }
-	            if (intentResolutionResultId) {
-	                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);
-	            }
-	            if (intentResult instanceof Error) {
-	                throw new Error(intentResult.message);
-	            }
-	            return intentResult;
-	        };
-	        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
-	    }
-	    /**
-	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
-	     * @param channelId
-	     *
-	     * @tutorial fdc3.getOrCreateChannel
-	     */
-	    async getOrCreateChannel(channelId) {
-	        return super.getOrCreateChannel(channelId);
-	    }
-	    /**
-	     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
-	     *
-	     * @tutorial fdc3v2.createPrivateChannel
-	     */
-	    async createPrivateChannel() {
-	        const channelId = (0, utils_1.generateId)();
-	        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });
-	        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
-	        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
-	        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);
-	    }
-	    /**
-	     * Retrieves a list of the User Channels available for the app to join.
-	     *
-	     * @tutorial fdc3v2.getUserChannels
-	     */
-	    async getUserChannels() {
-	        const channels = await this.client.getContextGroups();
-	        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over
-	        // this so people know that these APIs are not supported
-	        return channels.map((channel) => {
-	            // @ts-expect-error TODO [CORE-1524]
-	            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };
-	        });
-	    }
-	    /**
-	     * Retrieves a list of the User Channels available for the app to join.
-	     *
-	     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead
-	     * @tutorial fdc3.getSystemChannels
-	     */
-	    async getSystemChannels() {
-	        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');
-	        return super.getSystemChannels();
-	    }
-	    /**
-	     * Join an app to a specified User channel.
-	     * @param channelId Channel name
-	     *
-	     * @tutorial fdc3v2.joinUserChannel
-	     */
-	    async joinUserChannel(channelId) {
-	        return super.joinChannel(channelId);
-	    }
-	    /**
-	     * Join an app to a specified User channel.
-	     * @param channelId Channel name
-	     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead
-	     *
-	     * @tutorial fdc3.joinChannel
-	     */
-	    async joinChannel(channelId) {
-	        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');
-	        return super.joinChannel(channelId);
-	    }
-	    /**
-	     * Returns the Channel object for the current User channel membership
-	     *
-	     * @tutorial fdc3.getCurrentChannel
-	     */
-	    async getCurrentChannel() {
-	        const currentChannel = await super.getCurrentChannel();
-	        if (!currentChannel) {
-	            return null;
-	        }
-	        return {
-	            ...currentChannel,
-	            type: 'user',
-	            broadcast: this.broadcast.bind(this)
-	        };
-	    }
-	    /**
-	     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
-	     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
-	     *
-	     * @tutorial fdc3v2.getInfo
-	     */
-	    async getInfo() {
-	        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
-	    }
-	}
-	fdc32_0.Fdc3Module2 = Fdc3Module2;
-	return fdc32_0;
+var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _FDC3ModuleBase_producer;
+Object.defineProperty(fdc3Common, "__esModule", { value: true });
+fdc3Common.FDC3ModuleBase = void 0;
+const utils_1$2 = utils$1;
+const utils_2$1 = utils$2;
+const InteropClient_1$1 = InteropClient$1;
+const isEqual_1 = __importDefault(require$$2);
+class FDC3ModuleBase {
+    get client() {
+        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
+    }
+    get fin() {
+        return this.wire.getFin();
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(producer, wire) {
+        this.wire = wire;
+        _FDC3ModuleBase_producer.set(this, void 0);
+        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, "f");
+    }
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param context - New context to set.
+     *
+     * @tutorial fdc3.broadcast
+     * @static
+     */
+    async broadcast(context) {
+        this.wire.sendAction('fdc3-broadcast').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return this.client.setContext(context);
+    }
+    /**
+     * Launches an app with target information, which can either be a string or an AppMetadata object.
+     * @param app
+     * @param context
+     *
+     * @tutorial fdc3.open
+     */
+    async _open(app, context) {
+        this.wire.sendAction('fdc3-open').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1$1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$1.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    async _getChannels() {
+        const channels = await this.client.getContextGroups();
+        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over
+        // this so people know that these APIs are not supported
+        return channels.map((channel) => {
+            return { ...channel, type: 'system', ...(0, utils_1$2.getUnsupportedChannelApis)() };
+        });
+    }
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     *
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    async getOrCreateChannel(channelId) {
+        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const systemChannels = await this._getChannels();
+        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+        if (userChannel) {
+            return { ...userChannel, type: 'system', ...(0, utils_1$2.getUnsupportedChannelApis)() };
+        }
+        try {
+            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);
+            return (0, utils_1$2.buildAppChannelObject)(sessionContextGroup);
+        }
+        catch (error) {
+            console.error(error.message);
+            throw new Error(utils_1$2.ChannelError.CreationFailed);
+        }
+    }
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     *
+     * @tutorial fdc3.getSystemChannels
+     * @static
+     */
+    async getSystemChannels() {
+        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return this._getChannels();
+    }
+    /**
+     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+     * If no target is specified, it adds the sender to the context group.
+     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
+     * @param channelId - Id of the context group.
+     *
+     * @tutorial fdc3.joinChannel
+     * @static
+     */
+    async joinChannel(channelId) {
+        this.wire.sendAction('fdc3-join-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.client.joinContextGroup(channelId);
+        }
+        catch (error) {
+            if (error.message === utils_2$1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
+                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+            }
+            else {
+                console.error(error.message);
+            }
+            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+                throw new Error(utils_1$2.ChannelError.NoChannelFound);
+            }
+            throw new Error(utils_1$2.ChannelError.AccessDenied);
+        }
+    }
+    /**
+     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+     *
+     * @tutorial fdc3.getCurrentChannel
+     */
+    async getCurrentChannel() {
+        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();
+        if (!currentContextGroupInfo) {
+            return null;
+        }
+        return this.buildChannelObject(currentContextGroupInfo);
+    }
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     *
+     * @tutorial fdc3.leaveCurrentChannel
+     * @static
+     */
+    async leaveCurrentChannel() {
+        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return this.client.removeFromContextGroup();
+    }
+    // utils
+    // eslint-disable-next-line class-methods-use-this
+    async getCurrentContextGroupInfo() {
+        const contextGroups = await this.client.getContextGroups();
+        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
+            return this.client.getAllClientsInContextGroup(ctxGroup.id);
+        });
+        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
+        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
+            return clientIdentityArr.some((clientIdentity) => {
+                const { uuid, name } = clientIdentity;
+                return this.wire.me.uuid === uuid && this.wire.me.name === name;
+            });
+        });
+        return contextGroups[clientIdx];
+    }
+    async buildChannelObject(currentContextGroupInfo) {
+        // @ts-expect-error
+        return {
+            ...currentContextGroupInfo,
+            type: 'system',
+            addContextListener: (...[contextType, handler]) => {
+                let realHandler;
+                let realType;
+                if (typeof contextType === 'function') {
+                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+                    realHandler = contextType;
+                }
+                else {
+                    realHandler = handler;
+                    if (typeof contextType === 'string') {
+                        realType = contextType;
+                    }
+                }
+                const listener = (async () => {
+                    let first = true;
+                    const currentContext = await this.client.getCurrentContext(realType);
+                    const wrappedHandler = (context, contextMetadata) => {
+                        if (first) {
+                            first = false;
+                            if ((0, isEqual_1.default)(currentContext, context)) {
+                                return;
+                            }
+                        }
+                        // eslint-disable-next-line consistent-return
+                        return realHandler(context, contextMetadata);
+                    };
+                    return this.client.addContextHandler(wrappedHandler, realType);
+                })();
+                // @ts-expect-error TODO [CORE-1524]
+                return {
+                    ...listener,
+                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+                };
+            },
+            broadcast: this.broadcast.bind(this),
+            // @ts-expect-error Typescript fails to infer the returntype is a Promise
+            getCurrentContext: async (contextType) => {
+                const context = await this.client.getCurrentContext(contextType);
+                // @ts-expect-error Typescript fails to infer the returntype is a Promise
+                return context === undefined ? null : context;
+            }
+        };
+    }
 }
+fdc3Common.FDC3ModuleBase = FDC3ModuleBase;
+_FDC3ModuleBase_producer = new WeakMap();
 
-var hasRequiredInteropClient;
-
-function requireInteropClient () {
-	if (hasRequiredInteropClient) return InteropClient;
-	hasRequiredInteropClient = 1;
-	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-	    if (kind === "m") throw new TypeError("Private method is not writable");
-	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-	};
-	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-	};
-	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
-	Object.defineProperty(InteropClient, "__esModule", { value: true });
-	InteropClient.InteropClient = void 0;
-	const base_1 = base;
-	const SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);
-	const fdc3_1_2_1 = requireFdc31_2();
-	const fdc3_2_0_1 = requireFdc32_0();
-	const utils_1 = utils$2;
-	/**
-	 * The Interop Client API is broken up into two groups:
-	 *
-	 * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
-	 *
-	 * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
-	 *
-	 * ---
-	 *
-	 * All APIs are available at the `fin.me.interop` namespace.
-	 *
-	 * ---
-	 *
-	 * **You only need 2 things to participate in Interop Context Grouping:**
-	 * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
-	 * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
-	 *
-	 * ---
-	 *
-	 * ##### Constructor
-	 * Returned by {@link Interop.connectSync Interop.connectSync}.
-	 *
-	 * ---
-	 *
-	 * ##### Interop methods intended for Views
-	 *
-	 *
-	 * **Context Groups API**
-	 *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
-	 *  * {@link InteropClient#setContext setContext(context)}
-	 *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
-	 *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
-	 *
-	 *
-	 * **Intents API**
-	 *  * {@link InteropClient#fireIntent fireIntent(intent)}
-	 *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
-	 *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
-	 *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
-	 *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
-	 *
-	 * ##### Interop methods intended for Windows
-	 *  * {@link InteropClient#getContextGroups getContextGroups()}
-	 *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
-	 *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
-	 *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
-	 *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
-	 *
-	 */
-	let InteropClient$1 = class InteropClient extends base_1.Base {
-	    /**
-	     * @internal
-	     */
-	    constructor(wire, clientPromise) {
-	        super(wire);
-	        _InteropClient_clientPromise.set(this, void 0);
-	        _InteropClient_sessionContextGroups.set(this, void 0);
-	        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), "f");
-	        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, "f");
-	    }
-	    /*
-	    Client APIs
-	    */
-	    /**
-	     * Sets a context for the context group of the current entity.
-	     *
-	     * @remarks The entity must be part of a context group in order set a context.
-	     *
-	     * @param context - New context to set.
-	     *
-	     * @example
-	     * ```js
-	     * setInstrumentContext = async (ticker) => {
-	     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})
-	     * }
-	     *
-	     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument
-	     * instrumentElement.on('click', (evt) => {
-	     *     setInstrumentContext(evt.ticker)
-	     * })
-	     * ```
-	     */
-	    async setContext(context) {
-	        this.wire.sendAction('interop-client-set-context').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('setContext', { context });
-	    }
-	    /**
-	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,
-	     * it will receive all of its declared contexts.
-	     *
-	     * @param handler - Handler for incoming context.
-	     * @param contextType - The type of context you wish to handle.
-	     *
-	     * @example
-	     * ```js
-	     * function handleIncomingContext(contextInfo) {
-	     *     const { type, id } = contextInfo;
-	     *     switch (type) {
-	     *         case 'instrument':
-	     *             handleInstrumentContext(contextInfo);
-	     *             break;
-	     *         case 'country':
-	     *             handleCountryContext(contextInfo);
-	     *             break;
-	     *
-	     *         default:
-	     *             break;
-	     *     }
-	     * }
-	     *
-	     *
-	     * function handleInstrumentContext(contextInfo) {
-	     *     const { type, id } = contextInfo;
-	     *     console.log('contextInfo for instrument', contextInfo)
-	     * }
-	     *
-	     * function handleCountryContext(contextInfo) {
-	     *     const { type, id } = contextInfo;
-	     *     console.log('contextInfo for country', contextInfo)
-	     * }
-	     *
-	     * fin.me.interop.addContextHandler(handleIncomingContext);
-	     * ```
-	     *
-	     *
-	     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.
-	     *
-	     * ```js
-	     * function handleInstrumentContext(contextInfo) {
-	     *     const { type, id } = contextInfo;
-	     *     console.log('contextInfo for instrument', contextInfo)
-	     * }
-	     *
-	     * function handleCountryContext(contextInfo) {
-	     *     const { type, id } = contextInfo;
-	     *     console.log('contextInfo for country', contextInfo)
-	     * }
-	     *
-	     *
-	     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')
-	     * fin.me.interop.addContextHandler(handleCountryContext, 'country')
-	     * ```
-	     */
-	    async addContextHandler(handler, contextType) {
-	        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        if (typeof handler !== 'function') {
-	            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
-	        }
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        let handlerId;
-	        if (contextType) {
-	            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;
-	        }
-	        else {
-	            handlerId = 'invokeContextHandler';
-	        }
-	        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);
-	        client.register(handlerId, wrappedHandler);
-	        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
-	        return {
-	            unsubscribe: async () => {
-	                client.remove(handlerId);
-	                await client.dispatch('removeContextHandler', { handlerId });
-	            }
-	        };
-	    }
-	    /*
-	    Platform Window APIs
-	    */
-	    /**
-	     * Returns the Interop-Broker-defined context groups available for an entity to join.
-	     * Used by Platform Windows.
-	     *
-	     * @example
-	     * ```js
-	     * fin.me.interop.getContextGroups()
-	     *         .then(contextGroups => {
-	     *             contextGroups.forEach(contextGroup => {
-	     *                 console.log(contextGroup.displayMetadata.name)
-	     *                 console.log(contextGroup.displayMetadata.color)
-	     *             })
-	     *         })
-	     * ```
-	     */
-	    async getContextGroups() {
-	        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('getContextGroups');
-	    }
-	    /**
-	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
-	     * If no target is specified, it adds the sender to the context group.
-	     *
-	     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
-	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
-	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
-	     * Used by Platform Windows.
-	     *
-	     * @param contextGroupId - Id of the context group.
-	     * @param target - Identity of the entity you wish to join to a context group.
-	     *
-	     * @example
-	     * ```js
-	     * joinViewToContextGroup = async (contextGroupId, view) => {
-	     *     await fin.me.interop.joinContextGroup(contextGroupId, view);
-	     * }
-	     *
-	     * getLastFocusedView()
-	     *     .then(lastFocusedViewIdentity => {
-	     *         joinViewToContextGroup('red', lastFocusedViewIdentity)
-	     *     })
-	     * ```
-	     */
-	    async joinContextGroup(contextGroupId, target) {
-	        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        if (!contextGroupId) {
-	            throw new Error('No contextGroupId specified for joinContextGroup.');
-	        }
-	        return client.dispatch('joinContextGroup', { contextGroupId, target });
-	    }
-	    /**
-	     * Removes the specified target from a context group.
-	     * If no target is specified, it removes the sender from their context group.
-	     * Used by Platform Windows.
-	     *
-	     * @param target - Identity of the entity you wish to join to a context group.
-	     *
-	     * @example
-	     * ```js
-	     * removeViewFromContextGroup = async (view) => {
-	     *     await fin.me.interop.removeFromContextGroup(view);
-	     * }
-	     *
-	     * getLastFocusedView()
-	     *     .then(lastFocusedViewIdentity => {
-	     *         removeViewFromContextGroup(lastFocusedViewIdentity)
-	     *     })
-	     * ```
-	     */
-	    async removeFromContextGroup(target) {
-	        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('removeFromContextGroup', { target });
-	    }
-	    /**
-	     * Gets all clients for a context group.
-	     *
-	     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
-	     *
-	     * Returns the Interop-Broker-defined context groups available for an entity to join.
-	     * @param contextGroupId - The id of context group you wish to get clients for.
-	     *
-	     * @example
-	     * ```js
-	     * fin.me.interop.getAllClientsInContextGroup('red')
-	     *     .then(clientsInContextGroup => {
-	     *         console.log(clientsInContextGroup)
-	     *     })
-	     * ```
-	     */
-	    async getAllClientsInContextGroup(contextGroupId) {
-	        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        if (!contextGroupId) {
-	            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
-	        }
-	        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
-	    }
-	    /**
-	     * Gets display info for a context group
-	     *
-	     * @remarks Used by Platform Windows.
-	     * @param contextGroupId - The id of context group you wish to get display info for.
-	     *
-	     * @example
-	     * ```js
-	     * fin.me.interop.getInfoForContextGroup('red')
-	     *     .then(contextGroupInfo => {
-	     *         console.log(contextGroupInfo.displayMetadata.name)
-	     *         console.log(contextGroupInfo.displayMetadata.color)
-	     *     })
-	     * ```
-	     */
-	    async getInfoForContextGroup(contextGroupId) {
-	        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        if (!contextGroupId) {
-	            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
-	        }
-	        return client.dispatch('getInfoForContextGroup', { contextGroupId });
-	    }
-	    /**
-	     * Sends an intent to the Interop Broker to resolve.
-	     * @param intent - The combination of an action and a context that is passed to an application for resolution.
-	     *
-	     * @example
-	     * ```js
-	     * // View wants to fire an Intent after a user clicks on a ticker
-	     * tickerElement.on('click', (element) => {
-	     *     const ticker = element.innerText;
-	     *     const intent = {
-	     *         name: 'ViewChart',
-	     *         context: {type: 'fdc3.instrument', id: { ticker }}
-	     *     }
-	     *
-	     *     fin.me.interop.fireIntent(intent);
-	     * })
-	     * ```
-	     */
-	    async fireIntent(intent) {
-	        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
-	            // don't expose, this is only for api analytics purposes
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('fireIntent', intent);
-	    }
-	    /**
-	     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
-	     * @param handler - Registered function meant to handle a specific intent type.
-	     * @param intentName - The name of an intent.
-	     *
-	     * @example
-	     * ```js
-	     * const intentHandler = (intent) => {
-	     *     const { context } = intent;
-	     *     myViewChartHandler(context);
-	     * };
-	     *
-	     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');
-	     *
-	     * function myAppCloseSequence() {
-	     *     // to unsubscribe the handler, simply call:
-	     *     subscription.unsubscribe();
-	     * }
-	     * ```
-	     */
-	    async registerIntentHandler(handler, intentName, options) {
-	        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
-	            // don't expose, this is only for api analytics purposes
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        const handlerId = `intent-handler-${intentName}`;
-	        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);
-	        try {
-	            await client.register(handlerId, wrappedHandler);
-	            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
-	        }
-	        catch (error) {
-	            throw new Error('Unable to register intent handler');
-	        }
-	        return {
-	            unsubscribe: async () => {
-	                client.remove(handlerId);
-	            }
-	        };
-	    }
-	    /**
-	     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
-	     * last context of that type.
-	     * @param contextType
-	     *
-	     * @example
-	     * ```js
-	     * await fin.me.interop.joinContextGroup('yellow');
-	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
-	     * const currentContext = await fin.me.interop.getCurrentContext();
-	     *
-	     * // with a specific context
-	     * await fin.me.interop.joinContextGroup('yellow');
-	     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});
-	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
-	     * const currentContext = await fin.me.interop.getCurrentContext('country');
-	     * ```
-	     */
-	    async getCurrentContext(contextType) {
-	        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('getCurrentContext', { contextType });
-	    }
-	    /**
-	     * Get information for a particular Intent from the Interop Broker.
-	     *
-	     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.
-	     * The format for the response will be determined by the App Provider overriding the function.
-	     *
-	     * @param options
-	     *
-	     * @example
-	     * ```js
-	     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');
-	     * ```
-	     */
-	    async getInfoForIntent(options) {
-	        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('getInfoForIntent', options);
-	    }
-	    /**
-	     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
-	     *
-	     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.
-	     * The format for the response will be determined by the App Provider overriding the function.
-	     *
-	     * @param context
-	     *
-	     * @example
-	     * ```js
-	     * tickerElement.on('click', (element) => {
-	     *     const ticker = element.innerText;
-	     *
-	     *     const context = {
-	     *         type: 'fdc3.instrument',
-	     *         id: {
-	     *             ticker
-	     *         }
-	     *     }
-	     *
-	     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);
-	     * })
-	     * ```
-	     */
-	    async getInfoForIntentsByContext(context) {
-	        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('getInfoForIntentsByContext', context);
-	    }
-	    /**
-	     * Sends a Context that will be resolved to an Intent by the Interop Broker.
-	     * This context accepts a metadata property.
-	     *
-	     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.
-	     * The format for the response will be determined by the App Provider overriding the function.
-	     *
-	     * @param context
-	     *
-	     * @example
-	     * ```js
-	     * tickerElement.on('click', (element) => {
-	     *     const ticker = element.innerText;
-	     *
-	     *     const context = {
-	     *         type: 'fdc3.instrument',
-	     *         id: {
-	     *             ticker
-	     *         }
-	     *     }
-	     *
-	     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);
-	     * })
-	     * ```
-	     */
-	    async fireIntentForContext(context) {
-	        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.dispatch('fireIntentForContext', context);
-	    }
-	    /**
-	     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
-	     * If the sessionContextGroup doesn't exist, one will get created.
-	     *
-	     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.
-	     * @param sessionContextGroupId - Id of the context group.
-	     *
-	     * @example
-	     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:
-	     *
-	     * My color-picker View:
-	     * ```js
-	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
-	     *
-	     *     const myColorPickerElement = document.getElementById('color-palette-picker');
-	     *     myColorPickerElement.addEventListener('change', event => {
-	     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });
-	     *     });
-	     * ```
-	     *
-	     * In other views:
-	     * ```js
-	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
-	     *
-	     *     const changeColorPalette = ({ selection }) => {
-	     *         // change the color palette to the selection
-	     *     };
-	     *
-	     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.
-	     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');
-	     * ```
-	     */
-	    async joinSessionContextGroup(sessionContextGroupId) {
-	        try {
-	            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
-	            if (currentSessionContextGroup) {
-	                return currentSessionContextGroup.getUserInstance();
-	            }
-	            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
-	                sessionContextGroupId
-	            });
-	            if (hasConflict) {
-	                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
-	            }
-	            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
-	            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").set(sessionContextGroupId, newSessionContextGroup);
-	            return newSessionContextGroup.getUserInstance();
-	        }
-	        catch (error) {
-	            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
-	            throw error;
-	        }
-	    }
-	    /**
-	     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.
-	     * Only one listener per Interop Client can be set.
-	     * @param listener
-	     *
-	     * @example
-	     * ```js
-	     * const listener = (event) => {
-	     *     const { type, topic, brokerName} = event;
-	     *     console.log(`Disconnected from Interop Broker ${brokerName} `);
-	     * }
-	     *
-	     * await fin.me.interop.onDisconnection(listener);
-	     * ```
-	     */
-	    async onDisconnection(listener) {
-	        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {
-	            // don't expose, analytics-only call
-	        });
-	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
-	        return client.onDisconnection((event) => {
-	            const { uuid } = event;
-	            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });
-	        });
-	    }
-	    getFDC3Sync(version) {
-	        switch (version) {
-	            case '1.2':
-	                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);
-	            case '2.0':
-	                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);
-	            default:
-	                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);
-	        }
-	    }
-	    async getFDC3(version) {
-	        return this.getFDC3Sync(version);
-	    }
-	    /**
-	     * @internal
-	     *
-	     * 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, _InteropClient_clientPromise, "f");
-	        return client.dispatch(action, payload || null);
-	    }
-	};
-	InteropClient.InteropClient = InteropClient$1;
-	_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
-	return InteropClient;
+Object.defineProperty(fdc31_2, "__esModule", { value: true });
+exports.Fdc3Module = fdc31_2.Fdc3Module = void 0;
+const utils_1$1 = utils$2;
+const fdc3_common_1$1 = fdc3Common;
+/**
+ * @version 1.2
+ * 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}.
+ *
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '1.2'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+ *
+ * ```js
+ * function fdc3Action() {
+ *     // Make some fdc3 API calls here
+ * }
+ *
+ * if (window.fdc3) {
+ *    fdc3Action();
+ * } else {
+ *    window.addEventListener('fdc3Ready', fdc3Action);
+ * }
+ * ```
+ */
+class Fdc3Module extends fdc3_common_1$1.FDC3ModuleBase {
+    async open(app, context) {
+        // eslint-disable-next-line no-underscore-dangle
+        await super._open(app, context);
+    }
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param contextType - The type of context you wish to handle.
+     * @param handler - Handler for incoming context.
+     *
+     * @tutorial fdc3.addContextListener
+     * @static
+     */
+    // @ts-expect-error TODO [CORE-1524]
+    addContextListener(contextType, handler) {
+        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        let listener;
+        if (typeof contextType === 'function') {
+            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+            listener = this.client.addContextHandler(contextType);
+        }
+        else {
+            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);
+        }
+        return {
+            ...listener,
+            unsubscribe: () => listener.then((l) => l.unsubscribe())
+        };
+    }
+    /**
+     * Adds a listener for incoming Intents.
+     * @param intent - Name of the Intent
+     * @param handler - Handler for incoming Intent
+     *
+     * @tutorial fdc3.addIntentListener
+     * @static
+     */
+    addIntentListener(intent, handler) {
+        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const contextHandler = (raisedIntent) => {
+            const { context, metadata: intentMetadata } = raisedIntent;
+            const { metadata } = context;
+            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+            if (intentResolutionResultId) {
+                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);
+            }
+            handler(raisedIntent.context);
+        };
+        const listener = this.client.registerIntentHandler(contextHandler, intent, {
+            fdc3Version: '1.2'
+        });
+        return {
+            ...listener,
+            unsubscribe: () => listener.then((l) => l.unsubscribe())
+        };
+    }
+    /**
+     * Raises a specific intent.
+     * @param intent Name of the Intent.
+     * @param context Context associated with the Intent.
+     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+     *
+     * @tutorial fdc3.raiseIntent
+     * @static
+     */
+    async raiseIntent(intent, context, app) {
+        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const intentObj = app
+            ? { name: intent, context, metadata: { target: app } }
+            : { name: intent, context };
+        try {
+            return await this.client.fireIntent(intentObj);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1$1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context.
+     * @param intent Name of the Intent
+     * @param context
+     *
+     * @tutorial fdc3.findIntent
+     */
+    async findIntent(intent, context) {
+        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.client.getInfoForIntent({ name: intent, context });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1$1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Find all the available intents for a particular context.
+     * @param context
+     *
+     * @tutorial fdc3.findIntentsByContext
+     */
+    async findIntentsByContext(context) {
+        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.client.getInfoForIntentsByContext(context);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1$1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Finds and raises an intent against a target app based purely on context data.
+     * @param context
+     * @param app
+     *
+     * @tutorial fdc3.raiseIntentForContext
+     */
+    async raiseIntentForContext(context, app) {
+        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1$1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     *
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    async getOrCreateChannel(channelId) {
+        return super.getOrCreateChannel(channelId);
+    }
+    /**
+     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+     *
+     * @tutorial fdc3.getInfo
+     */
+    getInfo() {
+        this.wire.sendAction('fdc3-get-info').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const version = this.wire.environment.getAdapterVersionSync();
+        return {
+            providerVersion: version,
+            provider: `openfin-${this.wire.me.uuid}`,
+            fdc3Version: '1.2'
+        };
+    }
 }
+exports.Fdc3Module = fdc31_2.Fdc3Module = Fdc3Module;
 
-var hasRequiredFdc3Common;
-
-function requireFdc3Common () {
-	if (hasRequiredFdc3Common) return fdc3Common;
-	hasRequiredFdc3Common = 1;
-	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-	};
-	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-	    if (kind === "m") throw new TypeError("Private method is not writable");
-	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-	};
-	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	var _FDC3ModuleBase_producer;
-	Object.defineProperty(fdc3Common, "__esModule", { value: true });
-	fdc3Common.FDC3ModuleBase = void 0;
-	const utils_1 = utils$1;
-	const utils_2 = utils$2;
-	const InteropClient_1 = requireInteropClient();
-	const isEqual_1 = __importDefault(require$$2);
-	class FDC3ModuleBase {
-	    get client() {
-	        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
-	    }
-	    get fin() {
-	        return this.wire.getFin();
-	    }
-	    // eslint-disable-next-line no-useless-constructor
-	    constructor(producer, wire) {
-	        this.wire = wire;
-	        _FDC3ModuleBase_producer.set(this, void 0);
-	        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, "f");
-	    }
-	    /**
-	     * Broadcasts a context for the channel of the current entity.
-	     * @param context - New context to set.
-	     *
-	     * @tutorial fdc3.broadcast
-	     * @static
-	     */
-	    async broadcast(context) {
-	        this.wire.sendAction('fdc3-broadcast').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        return this.client.setContext(context);
-	    }
-	    /**
-	     * Launches an app with target information, which can either be a string or an AppMetadata object.
-	     * @param app
-	     * @param context
-	     *
-	     * @tutorial fdc3.open
-	     */
-	    async _open(app, context) {
-	        this.wire.sendAction('fdc3-open').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    async _getChannels() {
-	        const channels = await this.client.getContextGroups();
-	        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over
-	        // this so people know that these APIs are not supported
-	        return channels.map((channel) => {
-	            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
-	        });
-	    }
-	    /**
-	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
-	     * @param channelId
-	     *
-	     * @tutorial fdc3.getOrCreateChannel
-	     */
-	    async getOrCreateChannel(channelId) {
-	        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const systemChannels = await this._getChannels();
-	        const userChannel = systemChannels.find((channel) => channel.id === channelId);
-	        if (userChannel) {
-	            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
-	        }
-	        try {
-	            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);
-	            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
-	        }
-	        catch (error) {
-	            console.error(error.message);
-	            throw new Error(utils_1.ChannelError.CreationFailed);
-	        }
-	    }
-	    /**
-	     * Returns the Interop-Broker-defined context groups available for an entity to join.
-	     *
-	     * @tutorial fdc3.getSystemChannels
-	     * @static
-	     */
-	    async getSystemChannels() {
-	        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        return this._getChannels();
-	    }
-	    /**
-	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
-	     * If no target is specified, it adds the sender to the context group.
-	     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
-	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
-	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
-	     * @param channelId - Id of the context group.
-	     *
-	     * @tutorial fdc3.joinChannel
-	     * @static
-	     */
-	    async joinChannel(channelId) {
-	        this.wire.sendAction('fdc3-join-channel').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await this.client.joinContextGroup(channelId);
-	        }
-	        catch (error) {
-	            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
-	                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
-	            }
-	            else {
-	                console.error(error.message);
-	            }
-	            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
-	                throw new Error(utils_1.ChannelError.NoChannelFound);
-	            }
-	            throw new Error(utils_1.ChannelError.AccessDenied);
-	        }
-	    }
-	    /**
-	     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
-	     *
-	     * @tutorial fdc3.getCurrentChannel
-	     */
-	    async getCurrentChannel() {
-	        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();
-	        if (!currentContextGroupInfo) {
-	            return null;
-	        }
-	        return this.buildChannelObject(currentContextGroupInfo);
-	    }
-	    /**
-	     * Removes the specified target from a context group.
-	     * If no target is specified, it removes the sender from their context group.
-	     *
-	     * @tutorial fdc3.leaveCurrentChannel
-	     * @static
-	     */
-	    async leaveCurrentChannel() {
-	        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        return this.client.removeFromContextGroup();
-	    }
-	    // utils
-	    // eslint-disable-next-line class-methods-use-this
-	    async getCurrentContextGroupInfo() {
-	        const contextGroups = await this.client.getContextGroups();
-	        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
-	            return this.client.getAllClientsInContextGroup(ctxGroup.id);
-	        });
-	        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
-	        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
-	            return clientIdentityArr.some((clientIdentity) => {
-	                const { uuid, name } = clientIdentity;
-	                return this.wire.me.uuid === uuid && this.wire.me.name === name;
-	            });
-	        });
-	        return contextGroups[clientIdx];
-	    }
-	    async buildChannelObject(currentContextGroupInfo) {
-	        // @ts-expect-error
-	        return {
-	            ...currentContextGroupInfo,
-	            type: 'system',
-	            addContextListener: (...[contextType, handler]) => {
-	                let realHandler;
-	                let realType;
-	                if (typeof contextType === 'function') {
-	                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
-	                    realHandler = contextType;
-	                }
-	                else {
-	                    realHandler = handler;
-	                    if (typeof contextType === 'string') {
-	                        realType = contextType;
-	                    }
-	                }
-	                const listener = (async () => {
-	                    let first = true;
-	                    const currentContext = await this.client.getCurrentContext(realType);
-	                    const wrappedHandler = (context, contextMetadata) => {
-	                        if (first) {
-	                            first = false;
-	                            if ((0, isEqual_1.default)(currentContext, context)) {
-	                                return;
-	                            }
-	                        }
-	                        // eslint-disable-next-line consistent-return
-	                        return realHandler(context, contextMetadata);
-	                    };
-	                    return this.client.addContextHandler(wrappedHandler, realType);
-	                })();
-	                // @ts-expect-error TODO [CORE-1524]
-	                return {
-	                    ...listener,
-	                    unsubscribe: () => listener.then((l) => l.unsubscribe())
-	                };
-	            },
-	            broadcast: this.broadcast.bind(this),
-	            // @ts-expect-error Typescript fails to infer the returntype is a Promise
-	            getCurrentContext: async (contextType) => {
-	                const context = await this.client.getCurrentContext(contextType);
-	                // @ts-expect-error Typescript fails to infer the returntype is a Promise
-	                return context === undefined ? null : context;
-	            }
-	        };
-	    }
-	}
-	fdc3Common.FDC3ModuleBase = FDC3ModuleBase;
-	_FDC3ModuleBase_producer = new WeakMap();
-	return fdc3Common;
-}
+var fdc3 = {};
 
-var hasRequiredFdc31_2;
+var fdc32_0 = {};
 
-function requireFdc31_2 () {
-	if (hasRequiredFdc31_2) return fdc31_2;
-	hasRequiredFdc31_2 = 1;
-	Object.defineProperty(fdc31_2, "__esModule", { value: true });
-	fdc31_2.Fdc3Module = void 0;
-	const utils_1 = utils$2;
-	const fdc3_common_1 = requireFdc3Common();
-	/**
-	 * @version 1.2
-	 * 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}.
-	 *
-	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
-	 * property to its options:
-	 *
-	 * ```js
-	 * {
-	 *     autoShow: false,
-	 *     saveWindowState: true,
-	 *     url: 'https://openfin.co',
-	 *     fdc3InteropApi: '1.2'
-	 * }
-	 * ```
-	 *
-	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
-	 *
-	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
-	 *
-	 * ```js
-	 * function fdc3Action() {
-	 *     // Make some fdc3 API calls here
-	 * }
-	 *
-	 * if (window.fdc3) {
-	 *    fdc3Action();
-	 * } else {
-	 *    window.addEventListener('fdc3Ready', fdc3Action);
-	 * }
-	 * ```
-	 */
-	class Fdc3Module extends fdc3_common_1.FDC3ModuleBase {
-	    async open(app, context) {
-	        // eslint-disable-next-line no-underscore-dangle
-	        await super._open(app, context);
-	    }
-	    /**
-	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
-	     * @param contextType - The type of context you wish to handle.
-	     * @param handler - Handler for incoming context.
-	     *
-	     * @tutorial fdc3.addContextListener
-	     * @static
-	     */
-	    // @ts-expect-error TODO [CORE-1524]
-	    addContextListener(contextType, handler) {
-	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        let listener;
-	        if (typeof contextType === 'function') {
-	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
-	            listener = this.client.addContextHandler(contextType);
-	        }
-	        else {
-	            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);
-	        }
-	        return {
-	            ...listener,
-	            unsubscribe: () => listener.then((l) => l.unsubscribe())
-	        };
-	    }
-	    /**
-	     * Adds a listener for incoming Intents.
-	     * @param intent - Name of the Intent
-	     * @param handler - Handler for incoming Intent
-	     *
-	     * @tutorial fdc3.addIntentListener
-	     * @static
-	     */
-	    addIntentListener(intent, handler) {
-	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const contextHandler = (raisedIntent) => {
-	            const { context, metadata: intentMetadata } = raisedIntent;
-	            const { metadata } = context;
-	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
-	            if (intentResolutionResultId) {
-	                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);
-	            }
-	            handler(raisedIntent.context);
-	        };
-	        const listener = this.client.registerIntentHandler(contextHandler, intent, {
-	            fdc3Version: '1.2'
-	        });
-	        return {
-	            ...listener,
-	            unsubscribe: () => listener.then((l) => l.unsubscribe())
-	        };
-	    }
-	    /**
-	     * Raises a specific intent.
-	     * @param intent Name of the Intent.
-	     * @param context Context associated with the Intent.
-	     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
-	     *
-	     * @tutorial fdc3.raiseIntent
-	     * @static
-	     */
-	    async raiseIntent(intent, context, app) {
-	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const intentObj = app
-	            ? { name: intent, context, metadata: { target: app } }
-	            : { name: intent, context };
-	        try {
-	            return await this.client.fireIntent(intentObj);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Find out more information about a particular intent by passing its name, and optionally its context.
-	     * @param intent Name of the Intent
-	     * @param context
-	     *
-	     * @tutorial fdc3.findIntent
-	     */
-	    async findIntent(intent, context) {
-	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await this.client.getInfoForIntent({ name: intent, context });
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Find all the available intents for a particular context.
-	     * @param context
-	     *
-	     * @tutorial fdc3.findIntentsByContext
-	     */
-	    async findIntentsByContext(context) {
-	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await this.client.getInfoForIntentsByContext(context);
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Finds and raises an intent against a target app based purely on context data.
-	     * @param context
-	     * @param app
-	     *
-	     * @tutorial fdc3.raiseIntentForContext
-	     */
-	    async raiseIntentForContext(context, app) {
-	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        try {
-	            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });
-	        }
-	        catch (error) {
-	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;
-	            throw new Error(errorToThrow);
-	        }
-	    }
-	    /**
-	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
-	     * @param channelId
-	     *
-	     * @tutorial fdc3.getOrCreateChannel
-	     */
-	    async getOrCreateChannel(channelId) {
-	        return super.getOrCreateChannel(channelId);
-	    }
-	    /**
-	     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
-	     *
-	     * @tutorial fdc3.getInfo
-	     */
-	    getInfo() {
-	        this.wire.sendAction('fdc3-get-info').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
-	        const version = this.wire.environment.getAdapterVersionSync();
-	        return {
-	            providerVersion: version,
-	            provider: `openfin-${this.wire.me.uuid}`,
-	            fdc3Version: '1.2'
-	        };
-	    }
-	}
-	fdc31_2.Fdc3Module = Fdc3Module;
-	return fdc31_2;
+Object.defineProperty(fdc32_0, "__esModule", { value: true });
+exports.Fdc3Module2 = fdc32_0.Fdc3Module2 = void 0;
+const fdc3_common_1 = fdc3Common;
+const utils_1 = utils$2;
+const InteropClient_1 = InteropClient$1;
+const utils_2 = utils$1;
+const PrivateChannelClient_1 = PrivateChannelClient$1;
+/**
+ * @version 2.0
+ * 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-context-sharing Interop API}.
+ *
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '2.0'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+ *
+ * ```js
+ * function fdc3Action() {
+ *     // Make some fdc3 API calls here
+ * }
+ *
+ * if (window.fdc3) {
+ *    fdc3Action();
+ * } else {
+ *    window.addEventListener('fdc3Ready', fdc3Action);
+ * }
+ * ```
+ */
+class Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {
+    /**
+     * Launches an app, specified via an AppIdentifier object.
+     * @param app
+     * @param context
+     *
+     * @tutorial fdc3.open
+     */
+    async open(app, context) {
+        if (typeof app === 'string') {
+            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+        }
+        // eslint-disable-next-line no-underscore-dangle
+        return super._open(app, context);
+    }
+    /**
+     * Find all the available instances for a particular application.
+     * @param app
+     *
+     * @tutorial fdc3v2.findInstances
+     */
+    async findInstances(app) {
+        this.wire.sendAction('fdc3-find-instances').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
+     * @param app
+     *
+     * @tutorial fdc3v2.getAppMetadata
+     */
+    async getAppMetadata(app) {
+        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param contextType
+     * @param handler
+     *
+     * @tutorial fdc3.addContextListener
+     */
+    // @ts-expect-error TODO [CORE-1524]
+    async addContextListener(contextType, handler) {
+        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler
+        // here so it only gets passed these parameters
+        const getWrappedHandler = (handlerToWrap) => {
+            return (context) => {
+                const { contextMetadata, ...rest } = context;
+                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];
+                handlerToWrap(...args);
+            };
+        };
+        let actualHandler = handler;
+        let wrappedHandler = getWrappedHandler(actualHandler);
+        if (typeof contextType === 'function') {
+            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+            actualHandler = contextType;
+            wrappedHandler = getWrappedHandler(actualHandler);
+            return this.client.addContextHandler(wrappedHandler);
+        }
+        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);
+    }
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.
+     * @param intent Name of the Intent
+     * @param context Context
+     * @param resultType The type of result returned for any intent specified during resolution.
+     *
+     * @tutorial fdc3.findIntent
+     */
+    async findIntent(intent, context, resultType) {
+        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Find all the available intents for a particular context.
+     * @param context
+     * @param resultType The type of result returned for any intent specified during resolution.
+     *
+     * @tutorial fdc3v2.findIntentsByContext
+     */
+    async findIntentsByContext(context, resultType) {
+        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const payload = resultType ? { context, metadata: { resultType } } : context;
+        try {
+            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Raises a specific intent for resolution against apps registered with the desktop agent.
+     * @param intent Name of the Intent
+     * @param context Context associated with the Intent
+     * @param app
+     *
+     * @tutorial fdc3v2.raiseIntent
+     */
+    async raiseIntent(intent, context, app) {
+        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            if (typeof app === 'string') {
+                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+            }
+            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
+     * @param context Context associated with the Intent
+     * @param app
+     *
+     * @tutorial fdc3v2.raiseIntentForContext
+     */
+    async raiseIntentForContext(context, app) {
+        // TODO: We have to do the same thing we do for raiseIntent here as well.
+        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        try {
+            if (typeof app === 'string') {
+                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+            }
+            return (0, utils_2.getIntentResolution)(this.client, context, app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Adds a listener for incoming intents.
+     * @param intent  Name of the Intent
+     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.
+     *
+     * @tutorial fdc3.addIntentListener
+     */
+    async addIntentListener(intent, handler) {
+        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        if (typeof intent !== 'string') {
+            throw new Error('First argument must be an Intent name');
+        }
+        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
+        // so we wrap it here and only pass those paramaters.
+        const contextHandler = async (raisedIntent) => {
+            let intentResult;
+            let intentResultToSend;
+            const { context, metadata: intentMetadata } = raisedIntent;
+            const { contextMetadata, metadata, ...rest } = context;
+            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+            try {
+                const newContext = metadata ? { metadata, ...rest } : { ...rest };
+                intentResult = await handler(newContext, contextMetadata);
+                intentResultToSend = intentResult;
+            }
+            catch (error) {
+                intentResult = error;
+                intentResultToSend = { error: true };
+            }
+            if (intentResolutionResultId) {
+                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);
+            }
+            if (intentResult instanceof Error) {
+                throw new Error(intentResult.message);
+            }
+            return intentResult;
+        };
+        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
+    }
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     *
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    async getOrCreateChannel(channelId) {
+        return super.getOrCreateChannel(channelId);
+    }
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     *
+     * @tutorial fdc3v2.createPrivateChannel
+     */
+    async createPrivateChannel() {
+        const channelId = (0, utils_1.generateId)();
+        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });
+        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
+        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);
+    }
+    /**
+     * Retrieves a list of the User Channels available for the app to join.
+     *
+     * @tutorial fdc3v2.getUserChannels
+     */
+    async getUserChannels() {
+        const channels = await this.client.getContextGroups();
+        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over
+        // this so people know that these APIs are not supported
+        return channels.map((channel) => {
+            // @ts-expect-error TODO [CORE-1524]
+            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };
+        });
+    }
+    /**
+     * Retrieves a list of the User Channels available for the app to join.
+     *
+     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead
+     * @tutorial fdc3.getSystemChannels
+     */
+    async getSystemChannels() {
+        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');
+        return super.getSystemChannels();
+    }
+    /**
+     * Join an app to a specified User channel.
+     * @param channelId Channel name
+     *
+     * @tutorial fdc3v2.joinUserChannel
+     */
+    async joinUserChannel(channelId) {
+        return super.joinChannel(channelId);
+    }
+    /**
+     * Join an app to a specified User channel.
+     * @param channelId Channel name
+     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead
+     *
+     * @tutorial fdc3.joinChannel
+     */
+    async joinChannel(channelId) {
+        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');
+        return super.joinChannel(channelId);
+    }
+    /**
+     * Returns the Channel object for the current User channel membership
+     *
+     * @tutorial fdc3.getCurrentChannel
+     */
+    async getCurrentChannel() {
+        const currentChannel = await super.getCurrentChannel();
+        if (!currentChannel) {
+            return null;
+        }
+        return {
+            ...currentChannel,
+            type: 'user',
+            broadcast: this.broadcast.bind(this)
+        };
+    }
+    /**
+     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
+     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
+     *
+     * @tutorial fdc3v2.getInfo
+     */
+    async getInfo() {
+        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
+    }
 }
-
-var fdc31_2Exports = requireFdc31_2();
-
-var fdc3 = {};
+exports.Fdc3Module2 = fdc32_0.Fdc3Module2 = Fdc3Module2;
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -2275,8 +2276,8 @@ var fdc3 = {};
 	/* eslint-disable no-console */
 	/* eslint-disable no-param-reassign */
 	/* eslint-disable @typescript-eslint/no-non-null-assertion */
-	const fdc3_1_2_1 = requireFdc31_2();
-	const fdc3_2_0_1 = requireFdc32_0();
+	const fdc3_1_2_1 = fdc31_2;
+	const fdc3_2_0_1 = fdc32_0;
 	exports.versionMap = {
 	    '1.2': fdc3_1_2_1.Fdc3Module,
 	    '2.0': fdc3_2_0_1.Fdc3Module2
@@ -2295,13 +2296,9 @@ var fdc3 = {};
 	exports.getFdc3 = getFdc3; 
 } (fdc3));
 
-var fdc32_0Exports = requireFdc32_0();
-
 async function fdc3FromFin(fin, { fdc3Version } = { fdc3Version: '2.0' }) {
     // @ts-expect-error
     return fdc3.getFdc3(fin.wire, fdc3Version);
 }
 
-exports.Fdc3Module = fdc31_2Exports.Fdc3Module;
-exports.Fdc3Module2 = fdc32_0Exports.Fdc3Module2;
 exports.fdc3FromFin = fdc3FromFin;