@openfin/fdc3-api 36.78.10 → 36.78.12

package/out/fdc3-api.js

@@ -10,279 +10,279 @@ var base = {};
 
 var promises = {};
 
-Object.defineProperty(promises, "__esModule", { value: true });
-promises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;
-function promisify(func) {
-    return (...args) => new Promise((resolve, reject) => {
-        func(...args, (err, val) => (err ? reject(err) : resolve(val)));
-    });
-}
-promises.promisify = promisify;
-async function promiseMap(arr, asyncF) {
-    return Promise.all(arr.map(asyncF));
-}
-promises.promiseMap = promiseMap;
-async function serial(arr) {
-    const ret = [];
-    for (const func of arr) {
-        // eslint-disable-next-line no-await-in-loop
-        const next = await func();
-        ret.push(next);
-    }
-    return ret;
-}
-promises.serial = serial;
-async function promiseMapSerial(arr, func) {
-    return serial(arr.map((value, index, array) => () => func(value, index, array)));
-}
+Object.defineProperty(promises, "__esModule", { value: true });
+promises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;
+function promisify(func) {
+    return (...args) => new Promise((resolve, reject) => {
+        func(...args, (err, val) => (err ? reject(err) : resolve(val)));
+    });
+}
+promises.promisify = promisify;
+async function promiseMap(arr, asyncF) {
+    return Promise.all(arr.map(asyncF));
+}
+promises.promiseMap = promiseMap;
+async function serial(arr) {
+    const ret = [];
+    for (const func of arr) {
+        // eslint-disable-next-line no-await-in-loop
+        const next = await func();
+        ret.push(next);
+    }
+    return ret;
+}
+promises.serial = serial;
+async function promiseMapSerial(arr, func) {
+    return serial(arr.map((value, index, array) => () => func(value, index, array)));
+}
 promises.promiseMapSerial = promiseMapSerial;
 
-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$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 _EmitterBase_emitterAccessor;
-Object.defineProperty(base, "__esModule", { value: true });
-base.Reply = base.EmitterBase = base.Base = void 0;
-const promises_1 = promises;
-class Base {
-    /**
-     * @internal
-     */
-    constructor(wire) {
-        this.isNodeEnvironment = () => {
-            return this.wire.environment.constructor.name === 'NodeEnvironment';
-        };
-        this.isOpenFinEnvironment = () => {
-            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
-        };
-        this.isBrowserEnvironment = () => {
-            return this.wire.environment.constructor.name === 'BrowserEnvironment';
-        };
-        this.wire = wire;
-    }
-    get fin() {
-        return this.wire.getFin();
-    }
-    /**
-     * Provides access to the OpenFin representation of the current code context (usually a document
-     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.
-     *
-     * Useful for debugging in the devtools console, where this will intelligently type itself based
-     * on the context in which the devtools panel was opened.
-     */
-    get me() {
-        return this.wire.me;
-    }
-}
-base.Base = Base;
-/**
- * An entity that emits OpenFin events.
- *
- * @remarks Event-binding methods are asynchronous as they must cross process boundaries
- * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process
- * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values
- * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed
- * by page navigation or reload, any events that have been setup in that context will be destroyed.
- *
- * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally
- * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as
- * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.
- *
- * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
- * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
- * finally to the OpenFin runtime itself at the "system" level.  Re-propagated events are prefixed with the name of the scope in which
- * they originated - for example, a "shown" event emitted on a view will be re-propagated at the window level as "view-shown", and
- * then to the application as "window-view-shown", and finally at the system level as "application-window-view-shown".
- *
- * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window
- * to application) are visible in their entirety at the system level.  So, we can listen to the above event as "shown", "view-shown",
- * "window-view-shown", or "application-window-view-shown."
- */
-class EmitterBase extends Base {
-    constructor(wire, topic, ...additionalAccessors) {
-        super(wire);
-        this.topic = topic;
-        _EmitterBase_emitterAccessor.set(this, void 0);
-        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        /**
-         * @internal
-         */
-        this.emit = (eventType, payload, ...args) => {
-            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
-        };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
-        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
-        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
-        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
-        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
-            const runtimeEvent = {
-                ...this.identity,
-                timestamp: options.timestamp || Date.now(),
-                topic: this.topic,
-                type: eventType
-            };
-            const emitter = this.getOrCreateEmitter();
-            // We apply the subscription and then undo if the async call fails to avoid
-            // indeterminacy in subscription application order, which can break things elsewhere
-            applySubscription(emitter);
-            try {
-                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
-            }
-            catch (e) {
-                undoSubscription(emitter);
-                this.deleteEmitterIfNothingRegistered(emitter);
-                throw e;
-            }
-        };
-        this.deregisterEventListener = async (eventType, options = {}) => {
-            if (this.hasEmitter()) {
-                const runtimeEvent = {
-                    ...this.identity,
-                    timestamp: options.timestamp || Date.now(),
-                    topic: this.topic,
-                    type: eventType
-                };
-                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
-                const emitter = this.getOrCreateEmitter();
-                return emitter;
-            }
-            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
-            return Promise.resolve();
-        };
-        __classPrivateFieldSet$2(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
-        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
-    }
-    /**
-     * Adds a listener to the end of the listeners array for the specified event.
-     *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
-     */
-    async on(eventType, listener, options) {
-        await this.registerEventListener(eventType, options, (emitter) => {
-            emitter.on(eventType, listener);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-        });
-        return this;
-    }
-    /**
-     * Adds a listener to the end of the listeners array for the specified event.
-     */
-    async addListener(eventType, listener, options) {
-        return this.on(eventType, listener, options);
-    }
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
-     *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
-     */
-    async once(eventType, listener, options) {
-        const deregister = () => this.deregisterEventListener(eventType);
-        await this.registerEventListener(eventType, options, (emitter) => {
-            emitter.once(eventType, deregister);
-            emitter.once(eventType, listener);
-        }, (emitter) => {
-            emitter.removeListener(eventType, deregister);
-            emitter.removeListener(eventType, listener);
-        });
-        return this;
-    }
-    /**
-     * Adds a listener to the beginning of the listeners array for the specified event.
-     *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
-     */
-    async prependListener(eventType, listener, options) {
-        await this.registerEventListener(eventType, options, (emitter) => {
-            emitter.prependListener(eventType, listener);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-        });
-        return this;
-    }
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,
-     * after which it is removed. The listener is added to the beginning of the listeners array.
-     *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
-     */
-    async prependOnceListener(eventType, listener, options) {
-        const deregister = () => this.deregisterEventListener(eventType);
-        await this.registerEventListener(eventType, options, (emitter) => {
-            emitter.prependOnceListener(eventType, listener);
-            emitter.once(eventType, deregister);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-            emitter.removeListener(eventType, deregister);
-        });
-        return this;
-    }
-    /**
-     * Remove a listener from the listener array for the specified event.
-     *
-     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
-     */
-    async removeListener(eventType, listener, options) {
-        const emitter = await this.deregisterEventListener(eventType, options);
-        if (emitter) {
-            emitter.removeListener(eventType, listener);
-            this.deleteEmitterIfNothingRegistered(emitter);
-        }
-        return this;
-    }
-    async deregisterAllListeners(eventType) {
-        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
-        if (this.hasEmitter()) {
-            const emitter = this.getOrCreateEmitter();
-            const refCount = emitter.listenerCount(runtimeEvent.type);
-            const unsubscribePromises = [];
-            for (let i = 0; i < refCount; i++) {
-                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
-            }
-            await Promise.all(unsubscribePromises);
-            return emitter;
-        }
-        return undefined;
-    }
-    /**
-     * Removes all listeners, or those of the specified event.
-     *
-     */
-    async removeAllListeners(eventType) {
-        const removeByEvent = async (event) => {
-            const emitter = await this.deregisterAllListeners(event);
-            if (emitter) {
-                emitter.removeAllListeners(event);
-                this.deleteEmitterIfNothingRegistered(emitter);
-            }
-        };
-        if (eventType) {
-            await removeByEvent(eventType);
-        }
-        else if (this.hasEmitter()) {
-            const events = this.getOrCreateEmitter().eventNames();
-            await (0, promises_1.promiseMap)(events, removeByEvent);
-        }
-        return this;
-    }
-    deleteEmitterIfNothingRegistered(emitter) {
-        if (emitter.eventNames().length === 0) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
-        }
-    }
-}
-base.EmitterBase = EmitterBase;
-_EmitterBase_emitterAccessor = new WeakMap();
-class Reply {
-}
+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$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 _EmitterBase_emitterAccessor;
+Object.defineProperty(base, "__esModule", { value: true });
+base.Reply = base.EmitterBase = base.Base = void 0;
+const promises_1 = promises;
+class Base {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        this.isNodeEnvironment = () => {
+            return this.wire.environment.constructor.name === 'NodeEnvironment';
+        };
+        this.isOpenFinEnvironment = () => {
+            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
+        };
+        this.isBrowserEnvironment = () => {
+            return this.wire.environment.constructor.name === 'BrowserEnvironment';
+        };
+        this.wire = wire;
+    }
+    get fin() {
+        return this.wire.getFin();
+    }
+    /**
+     * Provides access to the OpenFin representation of the current code context (usually a document
+     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.
+     *
+     * Useful for debugging in the devtools console, where this will intelligently type itself based
+     * on the context in which the devtools panel was opened.
+     */
+    get me() {
+        return this.wire.me;
+    }
+}
+base.Base = Base;
+/**
+ * An entity that emits OpenFin events.
+ *
+ * @remarks Event-binding methods are asynchronous as they must cross process boundaries
+ * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process
+ * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values
+ * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed
+ * by page navigation or reload, any events that have been setup in that context will be destroyed.
+ *
+ * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally
+ * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as
+ * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.
+ *
+ * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
+ * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
+ * finally to the OpenFin runtime itself at the "system" level.  Re-propagated events are prefixed with the name of the scope in which
+ * they originated - for example, a "shown" event emitted on a view will be re-propagated at the window level as "view-shown", and
+ * then to the application as "window-view-shown", and finally at the system level as "application-window-view-shown".
+ *
+ * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window
+ * to application) are visible in their entirety at the system level.  So, we can listen to the above event as "shown", "view-shown",
+ * "window-view-shown", or "application-window-view-shown."
+ */
+class EmitterBase extends Base {
+    constructor(wire, topic, ...additionalAccessors) {
+        super(wire);
+        this.topic = topic;
+        _EmitterBase_emitterAccessor.set(this, void 0);
+        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
+        /**
+         * @internal
+         */
+        this.emit = (eventType, payload, ...args) => {
+            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
+        };
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
+        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
+        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
+        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
+            const runtimeEvent = {
+                ...this.identity,
+                timestamp: options.timestamp || Date.now(),
+                topic: this.topic,
+                type: eventType
+            };
+            const emitter = this.getOrCreateEmitter();
+            // We apply the subscription and then undo if the async call fails to avoid
+            // indeterminacy in subscription application order, which can break things elsewhere
+            applySubscription(emitter);
+            try {
+                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
+            }
+            catch (e) {
+                undoSubscription(emitter);
+                this.deleteEmitterIfNothingRegistered(emitter);
+                throw e;
+            }
+        };
+        this.deregisterEventListener = async (eventType, options = {}) => {
+            if (this.hasEmitter()) {
+                const runtimeEvent = {
+                    ...this.identity,
+                    timestamp: options.timestamp || Date.now(),
+                    topic: this.topic,
+                    type: eventType
+                };
+                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
+                const emitter = this.getOrCreateEmitter();
+                return emitter;
+            }
+            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
+            return Promise.resolve();
+        };
+        __classPrivateFieldSet$2(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
+        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async on(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.on(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     */
+    async addListener(eventType, listener, options) {
+        return this.on(eventType, listener, options);
+    }
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async once(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.once(eventType, deregister);
+            emitter.once(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, deregister);
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async prependListener(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependListener(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,
+     * after which it is removed. The listener is added to the beginning of the listeners array.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async prependOnceListener(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependOnceListener(eventType, listener);
+            emitter.once(eventType, deregister);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+            emitter.removeListener(eventType, deregister);
+        });
+        return this;
+    }
+    /**
+     * Remove a listener from the listener array for the specified event.
+     *
+     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
+     */
+    async removeListener(eventType, listener, options) {
+        const emitter = await this.deregisterEventListener(eventType, options);
+        if (emitter) {
+            emitter.removeListener(eventType, listener);
+            this.deleteEmitterIfNothingRegistered(emitter);
+        }
+        return this;
+    }
+    async deregisterAllListeners(eventType) {
+        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
+        if (this.hasEmitter()) {
+            const emitter = this.getOrCreateEmitter();
+            const refCount = emitter.listenerCount(runtimeEvent.type);
+            const unsubscribePromises = [];
+            for (let i = 0; i < refCount; i++) {
+                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
+            }
+            await Promise.all(unsubscribePromises);
+            return emitter;
+        }
+        return undefined;
+    }
+    /**
+     * Removes all listeners, or those of the specified event.
+     *
+     */
+    async removeAllListeners(eventType) {
+        const removeByEvent = async (event) => {
+            const emitter = await this.deregisterAllListeners(event);
+            if (emitter) {
+                emitter.removeAllListeners(event);
+                this.deleteEmitterIfNothingRegistered(emitter);
+            }
+        };
+        if (eventType) {
+            await removeByEvent(eventType);
+        }
+        else if (this.hasEmitter()) {
+            const events = this.getOrCreateEmitter().eventNames();
+            await (0, promises_1.promiseMap)(events, removeByEvent);
+        }
+        return this;
+    }
+    deleteEmitterIfNothingRegistered(emitter) {
+        if (emitter.eventNames().length === 0) {
+            this.wire.eventAggregator.delete(__classPrivateFieldGet$2(this, _EmitterBase_emitterAccessor, "f"));
+        }
+    }
+}
+base.EmitterBase = EmitterBase;
+_EmitterBase_emitterAccessor = new WeakMap();
+class Reply {
+}
 base.Reply = Reply;
 
 var utils$2 = {};
@@ -290,394 +290,394 @@ var utils$2 = {};
 var utils$1 = {};
 
 (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;
-	const generateId = () => `${Math.random()}${Date.now()}`;
-	exports.generateId = generateId;
-	const wrapInTryCatch = (f, prefix) => (...args) => {
-	    try {
-	        return f(...args);
-	    }
-	    catch (e) {
-	        throw new Error((prefix || '') + e);
-	    }
-	};
-	exports.wrapInTryCatch = wrapInTryCatch;
-	const wrapContextHandler = (handler, handlerId) => {
-	    return async (context) => {
-	        try {
-	            await handler(context);
-	        }
-	        catch (error) {
-	            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);
-	            throw error;
-	        }
-	    };
-	};
-	exports.wrapContextHandler = wrapContextHandler;
-	const generateOverrideError = (clientApi, brokerApi) => {
-	    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;
-	};
-	exports.generateOverrideError = generateOverrideError;
-	const generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {
-	    const { uuid, name } = identity;
-	    const message = interopClientApi
-	        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`
-	        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;
-	    return message;
-	};
-	exports.generateOverrideWarning = generateOverrideWarning;
-	exports.BROKER_ERRORS = {
-	    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),
-	    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),
-	    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),
-	    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
-	    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',
-	    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),
-	    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),
-	    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),
-	    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')
-	};
-	const wrapIntentHandler = (handler, handlerId) => {
-	    return async (intent) => {
-	        try {
-	            return handler(intent);
-	        }
-	        catch (error) {
-	            console.error(`Error thrown by handler ${handlerId}: ${error}`);
-	            throw error;
-	        }
-	    };
-	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	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) => {
+	    try {
+	        return f(...args);
+	    }
+	    catch (e) {
+	        throw new Error((prefix || '') + e);
+	    }
+	};
+	exports.wrapInTryCatch = wrapInTryCatch;
+	const wrapContextHandler = (handler, handlerId) => {
+	    return async (context) => {
+	        try {
+	            await handler(context);
+	        }
+	        catch (error) {
+	            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);
+	            throw error;
+	        }
+	    };
+	};
+	exports.wrapContextHandler = wrapContextHandler;
+	const generateOverrideError = (clientApi, brokerApi) => {
+	    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;
+	};
+	exports.generateOverrideError = generateOverrideError;
+	const generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {
+	    const { uuid, name } = identity;
+	    const message = interopClientApi
+	        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`
+	        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;
+	    return message;
+	};
+	exports.generateOverrideWarning = generateOverrideWarning;
+	exports.BROKER_ERRORS = {
+	    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),
+	    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),
+	    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),
+	    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
+	    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',
+	    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),
+	    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),
+	    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),
+	    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')
+	};
+	const wrapIntentHandler = (handler, handlerId) => {
+	    return async (intent) => {
+	        try {
+	            return handler(intent);
+	        }
+	        catch (error) {
+	            console.error(`Error thrown by handler ${handlerId}: ${error}`);
+	            throw error;
+	        }
+	    };
+	};
 	exports.wrapIntentHandler = wrapIntentHandler;
 } (utils$1));
 
 var PrivateChannelClient$1 = {};
 
-Object.defineProperty(PrivateChannelClient$1, "__esModule", { value: true });
-PrivateChannelClient$1.PrivateChannelClient = void 0;
-const utils = utils$1;
-class PrivateChannelClient {
-    constructor(client, id) {
-        this.id = id;
-        this.client = client;
-        this.listeners = new Map();
-    }
-    async broadcast(context) {
-        return this.client.dispatch('broadcast', { context });
-    }
-    async getCurrentContext(contextType) {
-        return this.client.dispatch('getCurrentContext', { contextType });
-    }
-    async addContextListener(contextType, handler) {
-        if (typeof handler !== 'function') {
-            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
-        }
-        let handlerId;
-        if (contextType) {
-            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils.generateId()}`;
-        }
-        else {
-            handlerId = `contextHandler:invoke-${this.id}-${utils.generateId()}`;
-        }
-        this.client.register(handlerId, utils.wrapContextHandler(handler, handlerId));
-        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
-        return listener;
-    }
-    createNonStandardUnsubscribeCb(handlerId) {
-        return async () => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
-        };
-    }
-    createContextUnsubscribeCb(handlerId) {
-        return async () => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-            await this.client.dispatch('contextHandlerRemoved', { handlerId });
-        };
-    }
-    onAddContextListener(handler) {
-        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils.generateId()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
-        return listener;
-    }
-    onDisconnect(handler) {
-        const handlerId = `onDisconnect:invoke-${this.id}-${utils.generateId()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
-        return listener;
-    }
-    onUnsubscribe(handler) {
-        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils.generateId()}`;
-        this.client.register(handlerId, handler);
-        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
-        this.listeners.set(handlerId, listener);
-        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
-        return listener;
-    }
-    async cleanUpAllSubs() {
-        const listenerUnsubscribers = Array.from(this.listeners.keys());
-        listenerUnsubscribers.forEach((handlerId) => {
-            this.client.remove(handlerId);
-            this.listeners.delete(handlerId);
-        });
-    }
-    async disconnect() {
-        try {
-            await this.client.dispatch('clientDisconnecting');
-            await this.cleanUpAllSubs();
-            await this.client.disconnect();
-        }
-        catch (error) {
-            throw new Error(error.message);
-        }
-    }
-}
+Object.defineProperty(PrivateChannelClient$1, "__esModule", { value: true });
+PrivateChannelClient$1.PrivateChannelClient = void 0;
+const utils = utils$1;
+class PrivateChannelClient {
+    constructor(client, id) {
+        this.id = id;
+        this.client = client;
+        this.listeners = new Map();
+    }
+    async broadcast(context) {
+        return this.client.dispatch('broadcast', { context });
+    }
+    async getCurrentContext(contextType) {
+        return this.client.dispatch('getCurrentContext', { contextType });
+    }
+    async addContextListener(contextType, handler) {
+        if (typeof handler !== 'function') {
+            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        let handlerId;
+        if (contextType) {
+            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils.generateId()}`;
+        }
+        else {
+            handlerId = `contextHandler:invoke-${this.id}-${utils.generateId()}`;
+        }
+        this.client.register(handlerId, utils.wrapContextHandler(handler, handlerId));
+        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
+        return listener;
+    }
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
+        };
+    }
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
+    }
+    onAddContextListener(handler) {
+        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onDisconnect(handler) {
+        const handlerId = `onDisconnect:invoke-${this.id}-${utils.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onUnsubscribe(handler) {
+        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
+        return listener;
+    }
+    async cleanUpAllSubs() {
+        const listenerUnsubscribers = Array.from(this.listeners.keys());
+        listenerUnsubscribers.forEach((handlerId) => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+        });
+    }
+    async disconnect() {
+        try {
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+}
 PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
 
 (function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
-	const utils_1 = utils$1;
-	const PrivateChannelClient_1 = PrivateChannelClient$1;
-	const lodash_1 = require$$2;
-	const getUnsupportedChannelApis = (channelType) => {
-	    return {
-	        addContextListener: () => {
-	            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);
-	        },
-	        broadcast: () => {
-	            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);
-	        },
-	        getCurrentContext: () => {
-	            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);
-	        }
-	    };
-	};
-	exports.getUnsupportedChannelApis = getUnsupportedChannelApis;
-	class UnsupportedChannelApiError extends Error {
-	    constructor(apiName, channelType = 'System') {
-	        super(apiName);
-	        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;
-	    }
-	}
-	exports.UnsupportedChannelApiError = UnsupportedChannelApiError;
-	var ResultError;
-	(function (ResultError) {
-	    /** Returned if the `IntentHandler` exited without returning a Promise or that
-	     *  Promise was not resolved with a Context or Channel object.
-	     */
-	    ResultError["NoResultReturned"] = "NoResultReturned";
-	    /** Returned if the `IntentHandler` function processing the raised intent
-	     *  throws an error or rejects the Promise it returned.
-	     */
-	    ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
-	})(ResultError = exports.ResultError || (exports.ResultError = {}));
-	(function (ChannelError) {
-	    /** Returned if the specified channel is not found when attempting to join a
-	     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
-	     */
-	    ChannelError["NoChannelFound"] = "NoChannelFound";
-	    /** SHOULD be returned when a request to join a user channel or to a retrieve
-	     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
-	     *  of the DesktopAgent (`fdc3`) object is denied.
-	     */
-	    ChannelError["AccessDenied"] = "AccessDenied";
-	    /** SHOULD be returned when a channel cannot be created or retrieved via the
-	     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
-	     */
-	    ChannelError["CreationFailed"] = "CreationFailed";
-	})(exports.ChannelError || (exports.ChannelError = {}));
-	const buildPrivateChannelObject = (privateChannelClient) => {
-	    let clientDisconnected = false;
-	    const checkIfClientDisconnected = () => {
-	        if (clientDisconnected) {
-	            throw new Error('Private Channel Client has been disconnected from the Private Channel');
-	        }
-	    };
-	    return {
-	        id: privateChannelClient.id,
-	        type: 'private',
-	        broadcast: async (context) => {
-	            checkIfClientDisconnected();
-	            return privateChannelClient.broadcast(context);
-	        },
-	        getCurrentContext: async (contextType) => {
-	            checkIfClientDisconnected();
-	            return privateChannelClient.getCurrentContext(contextType);
-	        },
-	        addContextListener: async (contextType, handler) => {
-	            checkIfClientDisconnected();
-	            let handlerInUse = handler;
-	            let contextTypeInUse = contextType;
-	            if (typeof contextType === 'function') {
-	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
-	                handlerInUse = contextType;
-	                contextTypeInUse = null;
-	            }
-	            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
-	            return listener;
-	        },
-	        onAddContextListener: (handler) => {
-	            checkIfClientDisconnected();
-	            return privateChannelClient.onAddContextListener(handler);
-	        },
-	        disconnect: async () => {
-	            checkIfClientDisconnected();
-	            clientDisconnected = true;
-	            return privateChannelClient.disconnect();
-	        },
-	        onDisconnect: (handler) => {
-	            checkIfClientDisconnected();
-	            return privateChannelClient.onDisconnect(handler);
-	        },
-	        onUnsubscribe: (handler) => {
-	            checkIfClientDisconnected();
-	            return privateChannelClient.onUnsubscribe(handler);
-	        }
-	    };
-	};
-	exports.buildPrivateChannelObject = buildPrivateChannelObject;
-	const buildAppChannelObject = (sessionContextGroup) => {
-	    return {
-	        id: sessionContextGroup.id,
-	        type: 'app',
-	        broadcast: sessionContextGroup.setContext,
-	        getCurrentContext: async (contextType) => {
-	            const context = await sessionContextGroup.getCurrentContext(contextType);
-	            return context === undefined ? null : context;
-	        },
-	        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 sessionContextGroup.getCurrentContext(realType);
-	                const wrappedHandler = (context, contextMetadata) => {
-	                    if (first) {
-	                        first = false;
-	                        if ((0, lodash_1.isEqual)(currentContext, context)) {
-	                            return;
-	                        }
-	                    }
-	                    // eslint-disable-next-line consistent-return
-	                    return realHandler(context, contextMetadata);
-	                };
-	                return sessionContextGroup.addContextHandler(wrappedHandler, realType);
-	            })();
-	            return {
-	                ...listener,
-	                unsubscribe: () => listener.then((l) => l.unsubscribe())
-	            };
-	        }
-	    };
-	};
-	exports.buildAppChannelObject = buildAppChannelObject;
-	const connectPrivateChannel = async (channelId) => {
-	    try {
-	        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
-	        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
-	        return (0, exports.buildPrivateChannelObject)(privateChannelClient);
-	    }
-	    catch (error) {
-	        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
-	    }
-	};
-	exports.connectPrivateChannel = connectPrivateChannel;
-	const isContext = (context) => {
-	    if (context && typeof context === 'object' && 'type' in context) {
-	        const { type } = context;
-	        return typeof type === 'string';
-	    }
-	    return false;
-	};
-	exports.isContext = isContext;
-	const isChannel = (channel) => {
-	    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
-	        const { type, id } = channel;
-	        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');
-	    }
-	    return false;
-	};
-	exports.isChannel = isChannel;
-	const getIntentResolution = async (interopModule, context, app, intent) => {
-	    // Generate an ID to make a session context group with. We will pass that ID to the Broker.
-	    // The broker will then setContext on that session context group later with our Intent Result,
-	    const guid = (0, utils_1.generateId)();
-	    // Promise we'll use in getResult
-	    const getResultPromise = new Promise((resolve) => {
-	        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
-	            resolve(intentResult);
-	        });
-	    });
-	    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.
-	    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };
-	    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
-	    // Set up the getResult call.
-	    const getResult = async () => {
-	        let intentResult = await getResultPromise;
-	        if (!intentResult || typeof intentResult !== 'object') {
-	            throw new Error(ResultError.NoResultReturned);
-	        }
-	        const { error } = intentResult;
-	        if (error) {
-	            throw new Error(ResultError.IntentHandlerRejected);
-	        }
-	        if ((0, exports.isChannel)(intentResult)) {
-	            const { id, type } = intentResult;
-	            switch (type) {
-	                case 'private': {
-	                    intentResult = await (0, exports.connectPrivateChannel)(id);
-	                    break;
-	                }
-	                case 'app': {
-	                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
-	                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
-	                    break;
-	                }
-	            }
-	        }
-	        else if (!(0, exports.isContext)(intentResult)) {
-	            throw new Error(ResultError.NoResultReturned);
-	        }
-	        return intentResult;
-	    };
-	    // Finally fire the intent.
-	    const intentResolutionInfoFromBroker = intent
-	        ? await interopModule.fireIntent(intentObj)
-	        : await interopModule.fireIntentForContext(intentObj);
-	    if (typeof intentResolutionInfoFromBroker !== 'object') {
-	        return {
-	            source: {
-	                appId: '',
-	                instanceId: ''
-	            },
-	            intent: '',
-	            version: '2.0',
-	            getResult
-	        };
-	    }
-	    return { ...intentResolutionInfoFromBroker, getResult };
-	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
+	const utils_1 = utils$1;
+	const PrivateChannelClient_1 = PrivateChannelClient$1;
+	const lodash_1 = require$$2;
+	const getUnsupportedChannelApis = (channelType) => {
+	    return {
+	        addContextListener: () => {
+	            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);
+	        },
+	        broadcast: () => {
+	            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);
+	        },
+	        getCurrentContext: () => {
+	            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);
+	        }
+	    };
+	};
+	exports.getUnsupportedChannelApis = getUnsupportedChannelApis;
+	class UnsupportedChannelApiError extends Error {
+	    constructor(apiName, channelType = 'System') {
+	        super(apiName);
+	        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;
+	    }
+	}
+	exports.UnsupportedChannelApiError = UnsupportedChannelApiError;
+	var ResultError;
+	(function (ResultError) {
+	    /** Returned if the `IntentHandler` exited without returning a Promise or that
+	     *  Promise was not resolved with a Context or Channel object.
+	     */
+	    ResultError["NoResultReturned"] = "NoResultReturned";
+	    /** Returned if the `IntentHandler` function processing the raised intent
+	     *  throws an error or rejects the Promise it returned.
+	     */
+	    ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
+	})(ResultError = exports.ResultError || (exports.ResultError = {}));
+	(function (ChannelError) {
+	    /** Returned if the specified channel is not found when attempting to join a
+	     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["NoChannelFound"] = "NoChannelFound";
+	    /** SHOULD be returned when a request to join a user channel or to a retrieve
+	     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+	     *  of the DesktopAgent (`fdc3`) object is denied.
+	     */
+	    ChannelError["AccessDenied"] = "AccessDenied";
+	    /** SHOULD be returned when a channel cannot be created or retrieved via the
+	     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["CreationFailed"] = "CreationFailed";
+	})(exports.ChannelError || (exports.ChannelError = {}));
+	const buildPrivateChannelObject = (privateChannelClient) => {
+	    let clientDisconnected = false;
+	    const checkIfClientDisconnected = () => {
+	        if (clientDisconnected) {
+	            throw new Error('Private Channel Client has been disconnected from the Private Channel');
+	        }
+	    };
+	    return {
+	        id: privateChannelClient.id,
+	        type: 'private',
+	        broadcast: async (context) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.broadcast(context);
+	        },
+	        getCurrentContext: async (contextType) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.getCurrentContext(contextType);
+	        },
+	        addContextListener: async (contextType, handler) => {
+	            checkIfClientDisconnected();
+	            let handlerInUse = handler;
+	            let contextTypeInUse = contextType;
+	            if (typeof contextType === 'function') {
+	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                handlerInUse = contextType;
+	                contextTypeInUse = null;
+	            }
+	            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
+	            return listener;
+	        },
+	        onAddContextListener: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onAddContextListener(handler);
+	        },
+	        disconnect: async () => {
+	            checkIfClientDisconnected();
+	            clientDisconnected = true;
+	            return privateChannelClient.disconnect();
+	        },
+	        onDisconnect: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onDisconnect(handler);
+	        },
+	        onUnsubscribe: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onUnsubscribe(handler);
+	        }
+	    };
+	};
+	exports.buildPrivateChannelObject = buildPrivateChannelObject;
+	const buildAppChannelObject = (sessionContextGroup) => {
+	    return {
+	        id: sessionContextGroup.id,
+	        type: 'app',
+	        broadcast: sessionContextGroup.setContext,
+	        getCurrentContext: async (contextType) => {
+	            const context = await sessionContextGroup.getCurrentContext(contextType);
+	            return context === undefined ? null : context;
+	        },
+	        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 sessionContextGroup.getCurrentContext(realType);
+	                const wrappedHandler = (context, contextMetadata) => {
+	                    if (first) {
+	                        first = false;
+	                        if ((0, lodash_1.isEqual)(currentContext, context)) {
+	                            return;
+	                        }
+	                    }
+	                    // eslint-disable-next-line consistent-return
+	                    return realHandler(context, contextMetadata);
+	                };
+	                return sessionContextGroup.addContextHandler(wrappedHandler, realType);
+	            })();
+	            return {
+	                ...listener,
+	                unsubscribe: () => listener.then((l) => l.unsubscribe())
+	            };
+	        }
+	    };
+	};
+	exports.buildAppChannelObject = buildAppChannelObject;
+	const connectPrivateChannel = async (channelId) => {
+	    try {
+	        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+	        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+	        return (0, exports.buildPrivateChannelObject)(privateChannelClient);
+	    }
+	    catch (error) {
+	        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+	    }
+	};
+	exports.connectPrivateChannel = connectPrivateChannel;
+	const isContext = (context) => {
+	    if (context && typeof context === 'object' && 'type' in context) {
+	        const { type } = context;
+	        return typeof type === 'string';
+	    }
+	    return false;
+	};
+	exports.isContext = isContext;
+	const isChannel = (channel) => {
+	    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
+	        const { type, id } = channel;
+	        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');
+	    }
+	    return false;
+	};
+	exports.isChannel = isChannel;
+	const getIntentResolution = async (interopModule, context, app, intent) => {
+	    // Generate an ID to make a session context group with. We will pass that ID to the Broker.
+	    // The broker will then setContext on that session context group later with our Intent Result,
+	    const guid = (0, utils_1.generateId)();
+	    // Promise we'll use in getResult
+	    const getResultPromise = new Promise((resolve) => {
+	        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
+	            resolve(intentResult);
+	        });
+	    });
+	    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.
+	    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };
+	    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
+	    // Set up the getResult call.
+	    const getResult = async () => {
+	        let intentResult = await getResultPromise;
+	        if (!intentResult || typeof intentResult !== 'object') {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        const { error } = intentResult;
+	        if (error) {
+	            throw new Error(ResultError.IntentHandlerRejected);
+	        }
+	        if ((0, exports.isChannel)(intentResult)) {
+	            const { id, type } = intentResult;
+	            switch (type) {
+	                case 'private': {
+	                    intentResult = await (0, exports.connectPrivateChannel)(id);
+	                    break;
+	                }
+	                case 'app': {
+	                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+	                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+	                    break;
+	                }
+	            }
+	        }
+	        else if (!(0, exports.isContext)(intentResult)) {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        return intentResult;
+	    };
+	    // Finally fire the intent.
+	    const intentResolutionInfoFromBroker = intent
+	        ? await interopModule.fireIntent(intentObj)
+	        : await interopModule.fireIntentForContext(intentObj);
+	    if (typeof intentResolutionInfoFromBroker !== 'object') {
+	        return {
+	            source: {
+	                appId: '',
+	                instanceId: ''
+	            },
+	            intent: '',
+	            version: '2.0',
+	            getResult
+	        };
+	    }
+	    return { ...intentResolutionInfoFromBroker, getResult };
+	};
 	exports.getIntentResolution = getIntentResolution;
 } (utils$2));
 
@@ -685,1470 +685,1470 @@ var InteropClient$1 = {};
 
 var SessionContextGroupClient$1 = {};
 
-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 _SessionContextGroupClient_clientPromise;
-Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
-const base_1$3 = base;
-const utils_1$3 = utils$1;
-class SessionContextGroupClient extends base_1$3.Base {
-    constructor(wire, client, id) {
-        super(wire);
-        _SessionContextGroupClient_clientPromise.set(this, void 0);
-        this.id = id;
-        __classPrivateFieldSet$1(this, _SessionContextGroupClient_clientPromise, client, "f");
-    }
-    /**
-     * Sets a context for the session context group.
-     * @param context - New context to set.
-     *
-     * @tutorial interop.setContext
-     */
-    async setContext(context) {
-        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$1(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            context
-        });
-    }
-    async getCurrentContext(type) {
-        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$1(this, _SessionContextGroupClient_clientPromise, "f");
-        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
-            sessionContextGroupId: this.id,
-            type
-        });
-    }
-    async addContextHandler(contextHandler, contextType) {
-        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        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$1(this, _SessionContextGroupClient_clientPromise, "f");
-        let handlerId;
-        if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$3.generateId)()}`;
-        }
-        else {
-            handlerId = `sessionContextHandler:invoke-${this.id}`;
-        }
-        client.register(handlerId, (0, utils_1$3.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$1(this, _SessionContextGroupClient_clientPromise, "f");
-        return async () => {
-            client.remove(handlerId);
-            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
-        };
-    }
-    getUserInstance() {
-        return {
-            id: this.id,
-            setContext: (0, utils_1$3.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
-            getCurrentContext: (0, utils_1$3.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
-            addContextHandler: (0, utils_1$3.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
-        };
-    }
-}
-SessionContextGroupClient$1.default = SessionContextGroupClient;
+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 _SessionContextGroupClient_clientPromise;
+Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
+const base_1$3 = base;
+const utils_1$3 = utils$1;
+class SessionContextGroupClient extends base_1$3.Base {
+    constructor(wire, client, id) {
+        super(wire);
+        _SessionContextGroupClient_clientPromise.set(this, void 0);
+        this.id = id;
+        __classPrivateFieldSet$1(this, _SessionContextGroupClient_clientPromise, client, "f");
+    }
+    /**
+     * Sets a context for the session context group.
+     * @param context - New context to set.
+     *
+     * @tutorial interop.setContext
+     */
+    async setContext(context) {
+        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _SessionContextGroupClient_clientPromise, "f");
+        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            context
+        });
+    }
+    async getCurrentContext(type) {
+        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _SessionContextGroupClient_clientPromise, "f");
+        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            type
+        });
+    }
+    async addContextHandler(contextHandler, contextType) {
+        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        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$1(this, _SessionContextGroupClient_clientPromise, "f");
+        let handlerId;
+        if (contextType) {
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$3.generateId)()}`;
+        }
+        else {
+            handlerId = `sessionContextHandler:invoke-${this.id}`;
+        }
+        client.register(handlerId, (0, utils_1$3.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$1(this, _SessionContextGroupClient_clientPromise, "f");
+        return async () => {
+            client.remove(handlerId);
+            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
+        };
+    }
+    getUserInstance() {
+        return {
+            id: this.id,
+            setContext: (0, utils_1$3.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: (0, utils_1$3.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: (0, utils_1$3.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
+        };
+    }
+}
+SessionContextGroupClient$1.default = SessionContextGroupClient;
 _SessionContextGroupClient_clientPromise = new WeakMap();
 
-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 _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
-Object.defineProperty(InteropClient$1, "__esModule", { value: true });
-InteropClient$1.InteropClient = void 0;
-const base_1$2 = base;
-const SessionContextGroupClient_1 = SessionContextGroupClient$1;
-const utils_1$2 = utils$1;
-/**
- * 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$2.Base {
-    /**
-     * @internal
-     */
-    constructor(wire, name, interopConfig = {}) {
-        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, this.wire.environment.whenReady().then(() => {
-            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
-                payload: interopConfig
-            });
-        }), "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);
-     * ```
-     *
-     *
-     * We are also testing the ability to add a context handler for specific contexts. If you would like to use
-     * this, please make sure you add your context handlers at the top level of your application, on a page that
-     * does not navigate/reload/re-render, to avoid memory leaks.  This feature is experimental:
-     *
-     * ```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$2.generateId)()}`;
-            console.warn(`Warning: By providing a contextType (${contextType}), you are using the experimental addContextHandler. To avoid issues, make sure you are adding your context handlers at the top level in your application.`);
-        }
-        else {
-            handlerId = 'invokeContextHandler';
-        }
-        const wrappedHandler = (0, utils_1$2.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$2.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 });
-        });
-    }
-    /**
-     * @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$1.InteropClient = InteropClient;
+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 _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
+Object.defineProperty(InteropClient$1, "__esModule", { value: true });
+InteropClient$1.InteropClient = void 0;
+const base_1$2 = base;
+const SessionContextGroupClient_1 = SessionContextGroupClient$1;
+const utils_1$2 = utils$1;
+/**
+ * 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$2.Base {
+    /**
+     * @internal
+     */
+    constructor(wire, name, interopConfig = {}) {
+        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, this.wire.environment.whenReady().then(() => {
+            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
+                payload: interopConfig
+            });
+        }), "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);
+     * ```
+     *
+     *
+     * We are also testing the ability to add a context handler for specific contexts. If you would like to use
+     * this, please make sure you add your context handlers at the top level of your application, on a page that
+     * does not navigate/reload/re-render, to avoid memory leaks.  This feature is experimental:
+     *
+     * ```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$2.generateId)()}`;
+            console.warn(`Warning: By providing a contextType (${contextType}), you are using the experimental addContextHandler. To avoid issues, make sure you are adding your context handlers at the top level in your application.`);
+        }
+        else {
+            handlerId = 'invokeContextHandler';
+        }
+        const wrappedHandler = (0, utils_1$2.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$2.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 });
+        });
+    }
+    /**
+     * @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$1.InteropClient = InteropClient;
 _InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
 
-Object.defineProperty(fdc31_2, "__esModule", { value: true });
-exports.Fdc3Module = fdc31_2.Fdc3Module = void 0;
-const base_1$1 = base;
-const utils_1$1 = utils$2;
-const utils_2$1 = utils$1;
-const InteropClient_1$1 = InteropClient$1;
-const lodash_1 = require$$2;
-/**
- * @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 base_1$1.Base {
-    /**
-     * 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
-     */
-    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.fin.me.interop.addContextHandler(contextType);
-        }
-        else {
-            listener = this.fin.me.interop.addContextHandler(handler, contextType === null ? undefined : contextType);
-        }
-        return {
-            ...listener,
-            unsubscribe: () => listener.then((l) => l.unsubscribe())
-        };
-    }
-    /**
-     * 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.fin.me.interop.setContext(context);
-    }
-    /**
-     * 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
-        });
-        const channels = await this.fin.me.interop.getContextGroups();
-        // fdc3 implementation of getSystemChannels returns on 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$1.getUnsupportedChannelApis)() };
-        });
-    }
-    /**
-     * 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.fin.me.interop.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$1.ChannelError.NoChannelFound);
-            }
-            throw new Error(utils_1$1.ChannelError.AccessDenied);
-        }
-    }
-    /**
-     * 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.fin.me.interop.removeFromContextGroup();
-    }
-    /**
-     * 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);
-            }
-            handler(raisedIntent.context);
-        };
-        const listener = this.fin.me.interop.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.fin.me.interop.fireIntent(intentObj);
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_2$1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
-            throw new Error(errorToThrow);
-        }
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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.fin.me.interop.getInfoForIntent({ name: intent, context });
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_2$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.fin.me.interop.getInfoForIntentsByContext(context);
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_2$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.fin.me.interop.fireIntentForContext({ ...context, metadata: { target: app } });
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_2$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) {
-        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.getSystemChannels();
-        const userChannel = systemChannels.find((channel) => channel.id === channelId);
-        if (userChannel) {
-            return { ...userChannel, type: 'system', ...(0, utils_1$1.getUnsupportedChannelApis)() };
-        }
-        try {
-            const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
-            return (0, utils_1$1.buildAppChannelObject)(sessionContextGroup);
-        }
-        catch (error) {
-            console.error(error.message);
-            throw new Error(utils_1$1.ChannelError.CreationFailed);
-        }
-    }
-    /**
-     * 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
-        });
-        // @ts-expect-error
-        const { uuid, fdc3InteropApi } = fin.__internal_.initialOptions;
-        // @ts-expect-error
-        const runtimeVersion = fin.desktop.getVersion();
-        return {
-            fdc3Version: fdc3InteropApi,
-            provider: `openfin-${uuid}`,
-            providerVersion: runtimeVersion
-        };
-    }
-    /**
-     * 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.fin.me.interop, 'fdc3Open', { app, context });
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_2$1.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
-            throw new Error(errorToThrow);
-        }
-    }
-    // utils
-    // eslint-disable-next-line class-methods-use-this
-    async getCurrentContextGroupInfo() {
-        const contextGroups = await this.fin.me.interop.getContextGroups();
-        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
-            return this.fin.me.interop.getAllClientsInContextGroup(ctxGroup.id);
-        });
-        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
-        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
-            return clientIdentityArr.some((clientIdentity) => {
-                const { uuid, name } = clientIdentity;
-                return this.fin.me.uuid === uuid && this.fin.me.name === name;
-            });
-        });
-        return contextGroups[clientIdx];
-    }
-    async buildChannelObject(currentContextGroupInfo) {
-        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.fin.me.interop.getCurrentContext(realType);
-                    const wrappedHandler = (context, contextMetadata) => {
-                        if (first) {
-                            first = false;
-                            if ((0, lodash_1.isEqual)(currentContext, context)) {
-                                return;
-                            }
-                        }
-                        // eslint-disable-next-line consistent-return
-                        return realHandler(context, contextMetadata);
-                    };
-                    return this.fin.me.interop.addContextHandler(wrappedHandler, realType);
-                })();
-                return {
-                    ...listener,
-                    unsubscribe: () => listener.then((l) => l.unsubscribe())
-                };
-            },
-            broadcast: this.broadcast.bind(this),
-            getCurrentContext: async (contextType) => {
-                const context = await this.fin.me.interop.getCurrentContext(contextType);
-                return context === undefined ? null : context;
-            }
-        };
-    }
-}
+Object.defineProperty(fdc31_2, "__esModule", { value: true });
+exports.Fdc3Module = fdc31_2.Fdc3Module = void 0;
+const base_1$1 = base;
+const utils_1$1 = utils$2;
+const utils_2$1 = utils$1;
+const InteropClient_1$1 = InteropClient$1;
+const lodash_1 = require$$2;
+/**
+ * @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 base_1$1.Base {
+    /**
+     * 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
+     */
+    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.fin.me.interop.addContextHandler(contextType);
+        }
+        else {
+            listener = this.fin.me.interop.addContextHandler(handler, contextType === null ? undefined : contextType);
+        }
+        return {
+            ...listener,
+            unsubscribe: () => listener.then((l) => l.unsubscribe())
+        };
+    }
+    /**
+     * 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.fin.me.interop.setContext(context);
+    }
+    /**
+     * 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
+        });
+        const channels = await this.fin.me.interop.getContextGroups();
+        // fdc3 implementation of getSystemChannels returns on 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$1.getUnsupportedChannelApis)() };
+        });
+    }
+    /**
+     * 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.fin.me.interop.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$1.ChannelError.NoChannelFound);
+            }
+            throw new Error(utils_1$1.ChannelError.AccessDenied);
+        }
+    }
+    /**
+     * 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.fin.me.interop.removeFromContextGroup();
+    }
+    /**
+     * 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);
+            }
+            handler(raisedIntent.context);
+        };
+        const listener = this.fin.me.interop.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.fin.me.interop.fireIntent(intentObj);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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.fin.me.interop.getInfoForIntent({ name: intent, context });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$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.fin.me.interop.getInfoForIntentsByContext(context);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$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.fin.me.interop.fireIntentForContext({ ...context, metadata: { target: app } });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$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) {
+        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.getSystemChannels();
+        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+        if (userChannel) {
+            return { ...userChannel, type: 'system', ...(0, utils_1$1.getUnsupportedChannelApis)() };
+        }
+        try {
+            const sessionContextGroup = await this.fin.me.interop.joinSessionContextGroup(channelId);
+            return (0, utils_1$1.buildAppChannelObject)(sessionContextGroup);
+        }
+        catch (error) {
+            console.error(error.message);
+            throw new Error(utils_1$1.ChannelError.CreationFailed);
+        }
+    }
+    /**
+     * 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
+        });
+        // @ts-expect-error
+        const { uuid, fdc3InteropApi } = fin.__internal_.initialOptions;
+        // @ts-expect-error
+        const runtimeVersion = fin.desktop.getVersion();
+        return {
+            fdc3Version: fdc3InteropApi,
+            provider: `openfin-${uuid}`,
+            providerVersion: runtimeVersion
+        };
+    }
+    /**
+     * 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.fin.me.interop, 'fdc3Open', { app, context });
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_2$1.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    // utils
+    // eslint-disable-next-line class-methods-use-this
+    async getCurrentContextGroupInfo() {
+        const contextGroups = await this.fin.me.interop.getContextGroups();
+        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
+            return this.fin.me.interop.getAllClientsInContextGroup(ctxGroup.id);
+        });
+        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
+        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
+            return clientIdentityArr.some((clientIdentity) => {
+                const { uuid, name } = clientIdentity;
+                return this.fin.me.uuid === uuid && this.fin.me.name === name;
+            });
+        });
+        return contextGroups[clientIdx];
+    }
+    async buildChannelObject(currentContextGroupInfo) {
+        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.fin.me.interop.getCurrentContext(realType);
+                    const wrappedHandler = (context, contextMetadata) => {
+                        if (first) {
+                            first = false;
+                            if ((0, lodash_1.isEqual)(currentContext, context)) {
+                                return;
+                            }
+                        }
+                        // eslint-disable-next-line consistent-return
+                        return realHandler(context, contextMetadata);
+                    };
+                    return this.fin.me.interop.addContextHandler(wrappedHandler, realType);
+                })();
+                return {
+                    ...listener,
+                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+                };
+            },
+            broadcast: this.broadcast.bind(this),
+            getCurrentContext: async (contextType) => {
+                const context = await this.fin.me.interop.getCurrentContext(contextType);
+                return context === undefined ? null : context;
+            }
+        };
+    }
+}
 exports.Fdc3Module = fdc31_2.Fdc3Module = Fdc3Module;
 
 var fdc3 = {};
 
 var fdc32_0 = {};
 
-Object.defineProperty(fdc32_0, "__esModule", { value: true });
-exports.Fdc3Module2 = fdc32_0.Fdc3Module2 = void 0;
-const base_1 = base;
-const utils_1 = utils$1;
-const InteropClient_1 = InteropClient$1;
-const utils_2 = utils$2;
-const fdc3_1_2_1 = fdc31_2;
-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 base_1.Base {
-    constructor(wire) {
-        super(wire);
-        // we get the module for fdc 1.2 here so we can reuse it wherever we can
-        this.fdc3Module = new fdc3_1_2_1.Fdc3Module(this.wire);
-    }
-    /**
-     * 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 }).');
-        }
-        return this.fdc3Module.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.fin.me.interop, '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.fin.me.interop, 'fdc3GetAppMetadata', app);
-        }
-        catch (error) {
-            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
-            throw new Error(errorToThrow);
-        }
-    }
-    /**
-     * Broadcasts a context for the channel of the current entity.
-     * @param context - New context to set.
-     *
-     * @tutorial fdc3.broadcast
-     */
-    async broadcast(context) {
-        return this.fdc3Module.broadcast(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
-     * @param handler
-     *
-     * @tutorial fdc3.addContextListener
-     */
-    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.fin.me.interop.addContextHandler(wrappedHandler);
-        }
-        return this.fin.me.interop.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.fin.me.interop.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.fin.me.interop, '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.fin.me.interop, 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.fin.me.interop, 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);
-            }
-            if (intentResult instanceof Error) {
-                throw new Error(intentResult.message);
-            }
-            return intentResult;
-        };
-        return this.fin.me.interop.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 this.fdc3Module.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.fin.me.interop, '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.fin.me.interop.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) => {
-            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 this.fdc3Module.getSystemChannels();
-    }
-    /**
-     * Join an app to a specified User channel.
-     * @param channelId Channel name
-     *
-     * @tutorial fdc3v2.joinUserChannel
-     */
-    async joinUserChannel(channelId) {
-        return this.fdc3Module.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 this.fdc3Module.joinChannel(channelId);
-    }
-    /**
-     * Returns the Channel object for the current User channel membership
-     *
-     * @tutorial fdc3.getCurrentChannel
-     */
-    async getCurrentChannel() {
-        const currentChannel = await this.fdc3Module.getCurrentChannel();
-        if (!currentChannel) {
-            return null;
-        }
-        return {
-            ...currentChannel,
-            type: 'user',
-            broadcast: this.broadcast.bind(this)
-        };
-    }
-    /**
-     * Removes the app from any User channel membership.
-     *
-     * @tutorial fdc3.leaveCurrentChannel
-     */
-    async leaveCurrentChannel() {
-        return this.fdc3Module.leaveCurrentChannel();
-    }
-    /**
-     * 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.fin.me.interop, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
-    }
-}
+Object.defineProperty(fdc32_0, "__esModule", { value: true });
+exports.Fdc3Module2 = fdc32_0.Fdc3Module2 = void 0;
+const base_1 = base;
+const utils_1 = utils$1;
+const InteropClient_1 = InteropClient$1;
+const utils_2 = utils$2;
+const fdc3_1_2_1 = fdc31_2;
+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 base_1.Base {
+    constructor(wire) {
+        super(wire);
+        // we get the module for fdc 1.2 here so we can reuse it wherever we can
+        this.fdc3Module = new fdc3_1_2_1.Fdc3Module(this.wire);
+    }
+    /**
+     * 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 }).');
+        }
+        return this.fdc3Module.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.fin.me.interop, '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.fin.me.interop, 'fdc3GetAppMetadata', app);
+        }
+        catch (error) {
+            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
+            throw new Error(errorToThrow);
+        }
+    }
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param context - New context to set.
+     *
+     * @tutorial fdc3.broadcast
+     */
+    async broadcast(context) {
+        return this.fdc3Module.broadcast(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
+     * @param handler
+     *
+     * @tutorial fdc3.addContextListener
+     */
+    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.fin.me.interop.addContextHandler(wrappedHandler);
+        }
+        return this.fin.me.interop.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.fin.me.interop.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.fin.me.interop, '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.fin.me.interop, 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.fin.me.interop, 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);
+            }
+            if (intentResult instanceof Error) {
+                throw new Error(intentResult.message);
+            }
+            return intentResult;
+        };
+        return this.fin.me.interop.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 this.fdc3Module.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.fin.me.interop, '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.fin.me.interop.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) => {
+            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 this.fdc3Module.getSystemChannels();
+    }
+    /**
+     * Join an app to a specified User channel.
+     * @param channelId Channel name
+     *
+     * @tutorial fdc3v2.joinUserChannel
+     */
+    async joinUserChannel(channelId) {
+        return this.fdc3Module.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 this.fdc3Module.joinChannel(channelId);
+    }
+    /**
+     * Returns the Channel object for the current User channel membership
+     *
+     * @tutorial fdc3.getCurrentChannel
+     */
+    async getCurrentChannel() {
+        const currentChannel = await this.fdc3Module.getCurrentChannel();
+        if (!currentChannel) {
+            return null;
+        }
+        return {
+            ...currentChannel,
+            type: 'user',
+            broadcast: this.broadcast.bind(this)
+        };
+    }
+    /**
+     * Removes the app from any User channel membership.
+     *
+     * @tutorial fdc3.leaveCurrentChannel
+     */
+    async leaveCurrentChannel() {
+        return this.fdc3Module.leaveCurrentChannel();
+    }
+    /**
+     * 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.fin.me.interop, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
+    }
+}
 exports.Fdc3Module2 = fdc32_0.Fdc3Module2 = Fdc3Module2;
 
 (function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.getFdc3 = exports.versionMap = void 0;
-	/* eslint-disable no-console */
-	/* eslint-disable no-param-reassign */
-	/* eslint-disable @typescript-eslint/no-non-null-assertion */
-	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
-	};
-	const latestVersion = '2.0';
-	function getFdc3(transport, version = latestVersion) {
-	    if (!(version in exports.versionMap)) {
-	        console.warn(`FDC3 API version: ${version} is not supported. Defaulting to latest version: ${latestVersion}.`);
-	        version = latestVersion;
-	    }
-	    const Fdc3Api = exports.versionMap[version];
-	    const fdc3 = new Fdc3Api(transport);
-	    window.dispatchEvent(new CustomEvent('fdc3Ready'));
-	    return fdc3;
-	}
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getFdc3 = exports.versionMap = void 0;
+	/* eslint-disable no-console */
+	/* eslint-disable no-param-reassign */
+	/* eslint-disable @typescript-eslint/no-non-null-assertion */
+	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
+	};
+	const latestVersion = '2.0';
+	function getFdc3(transport, version = latestVersion) {
+	    if (!(version in exports.versionMap)) {
+	        console.warn(`FDC3 API version: ${version} is not supported. Defaulting to latest version: ${latestVersion}.`);
+	        version = latestVersion;
+	    }
+	    const Fdc3Api = exports.versionMap[version];
+	    const fdc3 = new Fdc3Api(transport);
+	    window.dispatchEvent(new CustomEvent('fdc3Ready'));
+	    return fdc3;
+	}
 	exports.getFdc3 = getFdc3;
 } (fdc3));
 
@@ -2156,9 +2156,9 @@ var versions = {};
 
 Object.defineProperty(versions, "__esModule", { value: true });
 
-async function fdc3FromFin(fin, version) {
-    // @ts-expect-error
-    return fdc3.getFdc3(fin.wire, version);
+async function fdc3FromFin(fin, version) {
+    // @ts-expect-error
+    return fdc3.getFdc3(fin.wire, version);
 }
 
 exports.Fdc3Version = versions.Fdc3Version;