@openfin/core 30.73.6 → 30.73.7

package/src/api/interappbus/channel/provider.js

@@ -1,165 +1,166 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
+var __classPrivateFieldSet = (this && this.__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 = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
+var __classPrivateFieldGet = (this && this.__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 _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelProvider = void 0;
 const channel_1 = require("./channel");
 const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
-let ChannelProvider = /** @class */ (() => {
-    var _connections, _protectedObj, _strategy, _removeEndpoint, _close;
-    class ChannelProvider extends channel_1.ChannelBase {
-        constructor(providerIdentity, wire, strategy) {
-            super();
-            _connections.set(this, void 0);
-            _protectedObj.set(this, void 0);
-            _strategy.set(this, void 0);
-            _removeEndpoint.set(this, (identity) => {
-                const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
-                __classPrivateFieldGet(this, _strategy).closeEndpoint(identity.endpointId);
-                __classPrivateFieldSet(this, _connections, remainingConnections);
-            });
-            // Must be bound.
-            this.processAction = async (action, payload, senderIdentity) => {
-                if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
-                    !runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion(senderIdentity.runtimeUuid, '18.87.56.0')) {
-                    this.handleMultiRuntimeLegacyClient(senderIdentity);
-                }
-                else {
-                    this.checkForClientConnection(senderIdentity);
-                }
-                return super.processAction(action, payload, senderIdentity);
-            };
-            _close.set(this, () => {
-                __classPrivateFieldGet(this, _strategy).close();
-                const remove = ChannelProvider.removalMap.get(this);
-                if (remove) {
-                    remove();
-                }
-            });
-            __classPrivateFieldSet(this, _protectedObj, new channel_1.ProtectedItems(providerIdentity, wire));
-            this.connectListener = () => undefined;
-            this.disconnectListener = () => undefined;
-            __classPrivateFieldSet(this, _connections, []);
-            __classPrivateFieldSet(this, _strategy, strategy);
-            strategy.receive(this.processAction);
-        }
-        get connections() {
-            return [...__classPrivateFieldGet(this, _connections)];
-        }
-        static handleClientDisconnection(channel, payload) {
-            const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
-            if (removeById) {
-                __classPrivateFieldGet(channel, _removeEndpoint).call(channel, removeById);
+class ChannelProvider extends channel_1.ChannelBase {
+    constructor(providerIdentity, wire, strategy) {
+        super();
+        _ChannelProvider_connections.set(this, void 0);
+        _ChannelProvider_protectedObj.set(this, void 0);
+        _ChannelProvider_strategy.set(this, void 0);
+        _ChannelProvider_removeEndpoint.set(this, (identity) => {
+            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
+            __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet(this, _ChannelProvider_connections, remainingConnections, "f");
+        });
+        // Must be bound.
+        this.processAction = async (action, payload, senderIdentity) => {
+            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
+                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {
+                this.handleMultiRuntimeLegacyClient(senderIdentity);
             }
             else {
-                const multipleRemoves = channel.connections.filter((identity) => {
-                    return identity.uuid === payload.uuid && identity.name === payload.name;
-                });
-                multipleRemoves.forEach(__classPrivateFieldGet(channel, _removeEndpoint));
+                this.checkForClientConnection(senderIdentity);
             }
-            channel.disconnectListener(payload);
-        }
-        static setProviderRemoval(provider, remove) {
-            ChannelProvider.removalMap.set(provider, remove);
-        }
-        dispatch(to, action, payload) {
-            var _a;
-            const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);
-            if (endpointId && __classPrivateFieldGet(this, _strategy).isEndpointConnected(endpointId)) {
-                return __classPrivateFieldGet(this, _strategy).send(endpointId, action, payload);
+            return super.processAction(action, payload, senderIdentity);
+        };
+        _ChannelProvider_close.set(this, () => {
+            __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").close();
+            const remove = ChannelProvider.removalMap.get(this);
+            if (remove) {
+                remove();
             }
-            return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
-        }
-        async processConnection(senderId, payload) {
-            __classPrivateFieldGet(this, _connections).push(senderId);
-            return this.connectListener(senderId, payload);
-        }
-        publish(action, payload) {
-            return this.connections.map((to) => __classPrivateFieldGet(this, _strategy).send(to.endpointId, action, payload));
-        }
-        onConnection(listener) {
-            this.connectListener = listener;
-        }
-        onDisconnection(listener) {
-            this.disconnectListener = listener;
+        });
+        __classPrivateFieldSet(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, wire), "f");
+        this.connectListener = () => undefined;
+        this.disconnectListener = () => undefined;
+        __classPrivateFieldSet(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet(this, _ChannelProvider_strategy, strategy, "f");
+        strategy.receive(this.processAction);
+    }
+    get connections() {
+        return [...__classPrivateFieldGet(this, _ChannelProvider_connections, "f")];
+    }
+    static handleClientDisconnection(channel, payload) {
+        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+        if (removeById) {
+            __classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+        }
+        else {
+            const multipleRemoves = channel.connections.filter((identity) => {
+                return identity.uuid === payload.uuid && identity.name === payload.name;
+            });
+            multipleRemoves.forEach(__classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f"));
         }
-        async destroy() {
-            const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-            const { channelName } = protectedObj.providerIdentity;
-            __classPrivateFieldSet(this, _connections, []);
-            await protectedObj.wire.sendAction('destroy-channel', { channelName });
-            __classPrivateFieldGet(this, _close).call(this);
+        channel.disconnectListener(payload);
+    }
+    static setProviderRemoval(provider, remove) {
+        ChannelProvider.removalMap.set(provider, remove);
+    }
+    dispatch(to, action, payload) {
+        var _a;
+        const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);
+        if (endpointId && __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
         }
-        checkForClientConnection(clientIdentity) {
-            if (!this.isClientConnected(clientIdentity)) {
-                throw new Error(`This action was sent from a client that is not connected to the provider.
+        return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
+    }
+    async processConnection(senderId, payload) {
+        __classPrivateFieldGet(this, _ChannelProvider_connections, "f").push(senderId);
+        return this.connectListener(senderId, payload);
+    }
+    publish(action, payload) {
+        return this.connections.map((to) => __classPrivateFieldGet(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+    }
+    onConnection(listener) {
+        this.connectListener = listener;
+    }
+    onDisconnection(listener) {
+        this.disconnectListener = listener;
+    }
+    async destroy() {
+        const protectedObj = __classPrivateFieldGet(this, _ChannelProvider_protectedObj, "f");
+        const { channelName } = protectedObj.providerIdentity;
+        __classPrivateFieldSet(this, _ChannelProvider_connections, [], "f");
+        await protectedObj.wire.sendAction('destroy-channel', { channelName });
+        __classPrivateFieldGet(this, _ChannelProvider_close, "f").call(this);
+    }
+    async getAllClientInfo() {
+        return this.connections.map((clientInfo) => {
+            const { uuid, name, endpointId, entityType, connectionUrl } = clientInfo;
+            return { uuid, name, endpointId, entityType, connectionUrl };
+        });
+    }
+    checkForClientConnection(clientIdentity) {
+        if (!this.isClientConnected(clientIdentity)) {
+            throw new Error(`This action was sent from a client that is not connected to the provider.
                     Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);
-            }
-        }
-        isClientConnected(clientIdentity) {
-            if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
-                return this.connections.some((identity) => {
-                    return (
-                    // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
-                    identity.endpointId === clientIdentity.endpointId &&
-                        identity.uuid === clientIdentity.uuid &&
-                        identity.name === clientIdentity.name);
-                });
-            }
-            return this.isLegacyClientConnected(clientIdentity);
         }
-        isLegacyClientConnected(clientIdentity) {
+    }
+    isClientConnected(clientIdentity) {
+        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
             return this.connections.some((identity) => {
-                return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+                return (
+                // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
+                identity.endpointId === clientIdentity.endpointId &&
+                    identity.uuid === clientIdentity.uuid &&
+                    identity.name === clientIdentity.name);
             });
         }
-        handleMultiRuntimeLegacyClient(senderIdentity) {
-            if (!this.isLegacyClientConnected(senderIdentity)) {
-                throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:
+        return this.isLegacyClientConnected(clientIdentity);
+    }
+    isLegacyClientConnected(clientIdentity) {
+        return this.connections.some((identity) => {
+            return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+        });
+    }
+    handleMultiRuntimeLegacyClient(senderIdentity) {
+        if (!this.isLegacyClientConnected(senderIdentity)) {
+            throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:
                     {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);
-            }
         }
-        getEndpointIdForOpenFinId(clientIdentity, action) {
-            var _a;
-            const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
-            if (matchingConnections.length >= 2) {
-                const protectedObj = __classPrivateFieldGet(this, _protectedObj);
-                const { uuid, name } = clientIdentity;
-                const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
-                const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
-                // eslint-disable-next-line no-console
-                console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
+    }
+    getEndpointIdForOpenFinId(clientIdentity, action) {
+        var _a;
+        const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
+        if (matchingConnections.length >= 2) {
+            const protectedObj = __classPrivateFieldGet(this, _ChannelProvider_protectedObj, "f");
+            const { uuid, name } = clientIdentity;
+            const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
+            const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
+            // eslint-disable-next-line no-console
+            console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
                 "endpointId" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})
                 has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:
                 ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
-            }
-            // Pop to return the most recently created endpointId.
-            return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
-        }
-        // eslint-disable-next-line class-methods-use-this
-        static clientIdentityIncludesEndpointId(subscriptionIdentity) {
-            return subscriptionIdentity.endpointId !== undefined;
-        }
-        // eslint-disable-next-line class-methods-use-this
-        static clientIsMultiRuntime(subscriptionIdentity) {
-            return subscriptionIdentity.runtimeUuid !== undefined;
         }
+        // Pop to return the most recently created endpointId.
+        return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    static clientIdentityIncludesEndpointId(subscriptionIdentity) {
+        return subscriptionIdentity.endpointId !== undefined;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    static clientIsMultiRuntime(subscriptionIdentity) {
+        return subscriptionIdentity.runtimeUuid !== undefined;
     }
-    _connections = new WeakMap(), _protectedObj = new WeakMap(), _strategy = new WeakMap(), _removeEndpoint = new WeakMap(), _close = new WeakMap();
-    // The following line should be changed following a typescript update.
-    // static #removalMap = new WeakMap<ChannelProvider, Function>();
-    ChannelProvider.removalMap = new WeakMap();
-    return ChannelProvider;
-})();
+}
 exports.ChannelProvider = ChannelProvider;
+_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();
+// The following line should be changed following a typescript update.
+// static #removalMap = new WeakMap<ChannelProvider, Function>();
+ChannelProvider.removalMap = new WeakMap();

package/src/api/interappbus/index.js

@@ -54,7 +54,7 @@ class InterApplicationBus extends base_1.Base {
      * @tutorial InterApplicationBus.send
      */
     async send(destination, topic, message) {
-        const errorMsg = validate_1.validateIdentity(destination);
+        const errorMsg = (0, validate_1.validateIdentity)(destination);
         if (errorMsg) {
             throw new Error(errorMsg);
         }

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

@@ -1,7 +1,9 @@
+import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 import { InteropBroker } from './InteropBroker';
 import { InteropClient } from './InteropClient';
 /**
+ * @PORTED
  * @typedef { object } InteropConfig
  * @summary Information relevant to the Interop Broker.
  * @property {string} [currentContextGroup] Context Group for the client. (green, yellow, red, etc.)

package/src/api/interop/Factory.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const inaccessibleObject_1 = require("../../util/inaccessibleObject");
 const base_1 = require("../base");
 const InteropBroker_1 = require("./InteropBroker");
 const InteropClient_1 = require("./InteropClient");
-const defaultOverride = (Class, ...args) => new Class(...args);
+const overrideCheck_1 = require("./fdc3/overrideCheck");
+const defaultOverride = (Class) => new Class();
+const BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';
 /**
+ * @PORTED
  * @typedef { object } InteropConfig
  * @summary Information relevant to the Interop Broker.
  * @property {string} [currentContextGroup] Context Group for the client. (green, yellow, red, etc.)
@@ -26,11 +31,15 @@ class InteropModule extends base_1.Base {
      * @static
      */
     async init(name, override = defaultOverride) {
+        var _a;
         this.wire.sendAction('interop-init').catch((e) => {
             // don't expose, analytics-only call
         });
         // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)
         const options = await this.fin.Application.getCurrentSync().getInfo();
+        const opts = (_a = options.initialOptions.interopBrokerConfiguration) !== null && _a !== void 0 ? _a : {};
+        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);
+        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, lodash_1.cloneDeep)(opts));
         let provider;
         const getProvider = () => {
             if (!provider) {
@@ -38,7 +47,16 @@ class InteropModule extends base_1.Base {
             }
             return provider;
         };
-        return override(InteropBroker_1.InteropBroker, this.wire, getProvider, options.initialOptions.interopBrokerConfiguration || {});
+        const throwingGetProvider = async () => {
+            // eslint-disable-next-line no-console
+            throw new Error(BrokerParamAccessError);
+        };
+        const OverrideableBroker = InteropBroker_1.InteropBroker.createClosedConstructor(this.wire, getProvider, opts);
+        // We need to use these objects because removing them entirely would be a breaking change and we want an informative error
+        // @ts-expect-error
+        const broker = await override(OverrideableBroker, objectThatThrows, throwingGetProvider, warningOptsClone);
+        (0, overrideCheck_1.overrideCheck)(broker, (0, overrideCheck_1.getDefaultViewFdc3VersionFromAppInfo)(options));
+        return broker;
     }
     /**
      * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.

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

@@ -1,6 +1,9 @@
+import { TargetApp } from './fdc3/shapes/fdc3v1';
+import { AppIdentifier } from './fdc3/shapes/fdc3v2';
+import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 import type Transport from '../../transport/transport';
-import Identity = OpenFin.Identity;
+declare type Identity = OpenFin.Identity;
 /**
  * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking **THE INTEROP API IS EXPERIMENTAL. IF YOU WOULD LIKE TO USE IT, PLEASE USE OUR DEFAULT IMPLEMENTATION IN BROWSER**}
  *
@@ -46,6 +49,32 @@ import Identity = OpenFin.Identity;
  * }
  * ```
  *
+ * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:
+ * ```js
+ * {
+ *      "runtime": {
+ *          "arguments": "--v=1 --inspect",
+ *          "version": "alpha-v19"
+ *      },
+ *      "platform": {
+ *          "uuid": "platform_customization_local",
+ *          "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
+ *          "autoShow": false,
+ *          "providerUrl": "http://localhost:5555/provider.html",
+ *		    "interopBrokerConfiguration": {
+ *       		"logging": {
+ *   				"beforeAction": {
+ *   					"enabled": false
+ *   				},
+ *   				"afterAction": {
+ *   					"enabled": false
+ *   				}
+ *   			}
+ *		    }
+ *      }
+ * }
+ * ```
+ *
  * ---
  * **2. Overriding**
  *
@@ -74,7 +103,7 @@ import Identity = OpenFin.Identity;
  *         };
  *         return new Override();
  *     },
- *     interopOverride: async (InteropBroker, provider, options, ...args) => {
+ *     interopOverride: async (InteropBroker) => {
  *         class Override extends InteropBroker {
  *             async joinContextGroup(channelName = 'default', target) {
  *                 console.log('before super joinContextGroup')
@@ -83,37 +112,7 @@ import Identity = OpenFin.Identity;
  *             }
  *         }
  *
- *         options.contextGroups = [
- *             {
- *                 id: 'green',
- *                 displayMetadata: {
- *                     color: '#00CC88',
- *                     name: 'green'
- *                 }
- *             },
- *             {
- *                 id: 'purple',
- *                 displayMetadata: {
- *                     color: '#8C61FF',
- *                     name: 'purple'
- *                 }
- *             },
- *             {
- *                 id: 'orange',
- *                 displayMetadata: {
- *                     color: '#FF8C4C',
- *                     name: 'orange'
- *                 }
- *             },
- *             {
- *                 id: 'red',
- *                 displayMetadata: {
- *                     color: '#FF5E60',
- *                     name: 'red'
- *                 }
- *             }
- *         ];
- *       return new Override(provider, options, ...args);
+ *       return new Override();
  *   }
  * });
  * ```
@@ -131,44 +130,56 @@ export declare class InteropBroker extends Base {
     private lastContextMap;
     private sessionContextGroupMap;
     private channel;
+    private logging;
     constructor(wire: Transport, getProvider: () => Promise<OpenFin.ChannelProvider>, options?: any);
+    static createClosedConstructor(...args: ConstructorParameters<typeof InteropBroker>): {
+        new (): InteropBroker;
+    };
     /**
+     * @REMOVED
      * SetContextOptions interface
      * @typedef { object } SetContextOptions
      * @property { Context } {context} - New context to set.
      */
     /**
+     * @REMOVED
      * GetContextOptions interface
      * @typedef { object } GetContextOptions
      * @property { string } [contextType] - Context Type
      */
     /**
+     * @REMOVED
      * JoinContextGroupOptions interface
      * @typedef { object } JoinContextGroupOptions
      * @property { string } contextGroupId - Id of the context group.
      * @property { Identity | ClientIdentity } [target] - Identity of the entity you wish to join to a context group.
      */
     /**
+     * @REMOVED
      * AddClientToContextGroupOptions interface
      * @typedef { object } AddClientToContextGroupOptions
      * @property { string } contextGroupId - Name of the context group.
      */
     /**
+     * @REMOVED
      * RemoveFromContextGroupOptions interface
      * @typedef { object } RemoveFromContextGroupOptions
      * @property { Identity | ClientIdentity } target - Identity of the entity you wish to join to a context group.
      */
     /**
+     * @REMOVED
      * GetInfoForContextGroupOptions interface
      * @typedef { object } GetInfoForContextGroupOptions
      * @property { string } contextGroupId - Name of the context group to get info for.
      */
     /**
+     * @REMOVED
      * GetAllClientsInContextGroupOptions interface
      * @typedef { object } GetAllClientsInContextGroupOptions
      * @property { string } contextGroupId - Name of the context group to get info for.
      */
     /**
+     * @PORTED
      * InfoForIntentOptions interface
      * @typedef { object } InfoForIntentOptions
      * @property { string } name Name of the intent to get info for.
@@ -329,23 +340,23 @@ export declare class InteropBroker extends Base {
      * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
      */
     fdc3HandleOpen({ app, context }: {
-        app: FDC3.TargetApp | FDC3v2.AppIdentifier;
+        app: TargetApp | AppIdentifier;
         context: OpenFin.Context;
-    }, clientIdentity: OpenFin.ClientIdentity): Promise<void | FDC3v2.AppIdentifier>;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<void | AppIdentifier>;
     /**
      * Responsible for resolving the fdc3.findInstances call.
      * Must be overridden
      * @param { AppIdentifier(2) }  app AppIdentifier that was passed to fdc3.findInstances
      * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
      */
-    fdc3HandleFindInstances(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleFindInstances(app: AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Responsible for resolving the fdc3.getAppMetadata call.
      * Must be overridden
      * @param { AppIdentifier(2) } app AppIdentifier that was passed to fdc3.getAppMetadata
      * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
      */
-    fdc3HandleGetAppMetadata(app: FDC3v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleGetAppMetadata(app: AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * This function is called by the Interop Broker whenever a Context handler would fire.
      * For FDC3 2.0 you would need to override this function and add the contextMetadata as
@@ -377,7 +388,18 @@ export declare class InteropBroker extends Base {
      * @param clientIdentity
      * @returns { Promise<ImplementationMetadata(2)> }
      */
-    fdc3HandleGetInfo(clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleGetInfo(payload: {
+        fdc3Version: string;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    /**
+     * Returns an array of info for each Interop Client connected to the Interop Broker.
+     *
+     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating
+     * an AppIdentifier.
+     * @return { Promise<Array<ClientInfo>> }
+     * @tutorial interop.getAllClientInfo
+     */
+    getAllClientInfo(): Promise<Array<OpenFin.ClientInfo>>;
     decorateSnapshot(snapshot: OpenFin.Snapshot): OpenFin.Snapshot;
     applySnapshot(snapshot: OpenFin.Snapshot, options: OpenFin.ApplySnapshotOptions): void;
     updateExistingClients(contextGroupStates: OpenFin.ContextGroupStates): void;
@@ -407,7 +429,7 @@ export declare class InteropBroker extends Base {
     private static hasEndpointId;
     static isContextTypeCompatible(contextType: string, registeredContextType: string | undefined): boolean;
     private setContextGroupMap;
-    private static setCurrentContextGroupInClientOptions;
+    private setCurrentContextGroupInClientOptions;
     private setupChannelProvider;
     private wireChannel;
     /**
@@ -425,3 +447,4 @@ export declare class InteropBroker extends Base {
      */
     isActionAuthorized(_action: string, _payload: any, _identity: OpenFin.ClientIdentity): Promise<boolean> | boolean;
 }
+export {};