@openfin/core 33.76.31 → 33.76.36

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

@@ -9,6 +9,9 @@ type Identity = OpenFin.Identity;
  *
  * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.
  *
+ * @remarks This class contains some types related to FDC3 that are specific to OpenFin. {@link https://developers.openfin.co/of-docs/docs/fdc3-support-in-openfin OpenFin's FDC3 support} is forward- and backward-compatible.
+ * Standard types for {@link https://fdc3.finos.org/ FDC3} do not appear in OpenFin’s API documentation, to avoid duplication.
+ *
  * ---
  *
  * There are 2 ways to inject custom functionality into the Interop Broker:
@@ -78,7 +81,7 @@ type Identity = OpenFin.Identity;
  * ---
  * **2. Overriding**
  *
- * Similarly to how [Platform Overriding]{@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.
+ * Similarly to how {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior Platform Overriding} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.
  *
  * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.
  *
@@ -119,8 +122,6 @@ type Identity = OpenFin.Identity;
  *
  * ---
  *
- * @hideconstructor
- * @class
  */
 export declare class InteropBroker extends Base {
     private getProvider;
@@ -131,6 +132,9 @@ export declare class InteropBroker extends Base {
     private sessionContextGroupMap;
     private channel;
     private logging;
+    /**
+     * @internal
+     */
     constructor(wire: Transport, getProvider: () => Promise<OpenFin.ChannelProvider>, options?: any);
     static createClosedConstructor(...args: ConstructorParameters<typeof InteropBroker>): {
         new (): InteropBroker;
@@ -187,18 +191,21 @@ export declare class InteropBroker extends Base {
      */
     /**
      * Sets a context for the context group of the incoming current entity.
-     * @param { SetContextOptions } setContextOptions - New context to set.
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
-     * @return { void }
+     * @param setContextOptions - New context to set.
+     * @param clientIdentity - Identity of the client sender.
+     *
      */
     setContext({ context }: {
         context: OpenFin.Context;
     }, clientIdentity: OpenFin.ClientIdentity): void;
     /**
      * Get current context for a client subscribed to a Context Group.
-     * @param { GetContextOptions } getContextOptions - Options for getting context
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
-     * @return { Context }
+     *
+     * @remarks It takes an optional Context Type argument and returns the last context of that type.
+     *
+     * @param getContextOptions - Options for getting context
+     * @param clientIdentity - Identity of the client sender.
+     *
      */
     getCurrentContext(getCurrentContextOptions: {
         contextType: string;
@@ -208,9 +215,9 @@ export declare class InteropBroker extends Base {
      * If no target is specified, it adds the sender to the context group.
      * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.
      * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { JoinContextGroupOptions } joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.
-     * @param { ClientIdentity } senderIdentity - Identity of the client sender.
+     *
+     * @param joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.
+     * @param senderIdentity - Identity of the client sender.
      */
     joinContextGroup({ contextGroupId, target }: {
         contextGroupId: string;
@@ -219,9 +226,9 @@ export declare class InteropBroker extends Base {
     /**
      * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.
      * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { AddClientToContextGroupOptions } addClientToContextGroupOptions - Contains the contextGroupId
-     * @param { ClientIdentity } clientIdentity - Identity of the client sender.
+     *
+     * @param addClientToContextGroupOptions - Contains the contextGroupId
+     * @param clientIdentity - Identity of the client sender.
      */
     addClientToContextGroup({ contextGroupId }: {
         contextGroupId: string;
@@ -229,11 +236,13 @@ export declare class InteropBroker extends Base {
     /**
      * Removes the specified target from a context group.
      * If no target is specified, it removes the sender from their context group.
-     * removeFromContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup the client.
-     * Used by Platform Windows.
-     * @return { Promise<void> }
-     * @param { RemoveFromContextGroupOptions } removeFromContextGroupOptions - Contains the target identity to remove.
-     * @param { ClientIdentity } senderIdentity - Identity of the client sender.
+     * removeFromContextGroup is responsible for checking connections at the incoming identity.
+     *
+     * @remarks It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup
+     * the client. Used by Platform Windows.
+     *
+     * @param removeFromContextGroupOptions - Contains the target identity to remove.
+     * @param senderIdentity - Identity of the client sender.
      */
     removeFromContextGroup({ target }: {
         target: OpenFin.Identity;
@@ -241,30 +250,35 @@ export declare class InteropBroker extends Base {
     /**
      * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.
      * Used by Platform Windows.
-     * @return { Promise<void> }
+     *
      * @property { ClientIdentity } clientIdentity - Identity of the client sender.
      */
     removeClientFromContextGroup(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
     /**
      * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.
      * Used by Platform Windows.
-     * @return { Promise<ContextGroupInfo[]>}
+     *
      */
     getContextGroups(): Readonly<OpenFin.ContextGroupInfo[]>;
     /**
      * Gets display info for a context group
-     * Used by Platform Windows.
-     * @param { GetInfoForContextGroupOptions } getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.
-     * @return { Promise<ContextGroupInfo>}
+     *
+     * @remarks Used by Platform Windows.
+     *
+     * @param getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.
+     *
      */
     getInfoForContextGroup({ contextGroupId }: {
         contextGroupId: string;
     }): OpenFin.ContextGroupInfo | undefined;
     /**
      * Gets all clients for a context group.
-     * Used by Platform Windows.
-     * @param { GetAllClientsInContextGroupOptions } getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.
-     * @return { Promise<ClientIdentity[]>}
+     *
+     * @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 getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.
+     *
      */
     getAllClientsInContextGroup({ contextGroupId }: {
         contextGroupId: string;
@@ -272,59 +286,191 @@ export declare class InteropBroker extends Base {
     /**
      * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.
      * Must be overridden.
-     * @param { Intent } intent The combination of an action and a context that is passed to an application for resolution.
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleFiredIntent
+     *
+     * @remarks To make this call FDC3-Compliant it would need to return an IntentResolution.
+     *
+     * ```js
+     * interface IntentResolution {
+     *   source: TargetApp;
+     *   // deprecated, not assignable from intent listeners
+     *   data?: object;
+     *   version: string;
+     * }
+     * ```
+     *
+     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).
+     *
+     * @param intent The combination of an action and a context that is passed to an application for resolution.
+     * @param  clientIdentity Identity of the Client making the request.
+     *
+     * @example
+     * ```js
+     * // override call so we set intent target and create view that will handle it
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async handleFiredIntent(intent) {
+     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });
+     *                 const platform = fin.Platform.getCurrentSync();
+     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });
+     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     handleFiredIntent(intent: OpenFin.Intent, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
      * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.
-     * @param { Intent } intent The combination of an action and a context that is passed to an application for resolution.
-     * @param { Identity } target - Identity of the target that will handle the intent.
-     * @return { Promise<void> }
+     * @param intent The combination of an action and a context that is passed to an application for resolution.
+     * @param target - Identity of the target that will handle the intent.
+     *
      */
     setIntentTarget(intent: OpenFin.Intent, target: OpenFin.Identity): Promise<void>;
     /**
      * Responsible for returning information on a particular Intent.
-     * Must be overridden.
-     * @param { InfoForIntentOptions } options
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleInfoForIntent
+     *
+     * @remarks Whenever InteropClient.getInfoForIntent is called this function will fire. The options argument gives you
+     * access to the intent name and any optional context that was passed and clientIdentity is the identity of the client
+     * that made the call. Ideally here you would fetch the info for the intent and return it with the shape that the
+     * InteropClient.getInfoForIntent call is expecting.
+     *
+     * To make this call FDC3-Compliant it would need to return an App Intent:
+     *
+     * ```js
+     * // {
+     * //     intent: { name: "StartChat", displayName: "Chat" },
+     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+     * // }
+     * ```
+     *
+     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).
+     *
+     * @param options
+     * @param  clientIdentity Identity of the Client making the request.
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async handleInfoForIntent(options, clientIdentity) {
+     *                 // Your code goes here.
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     handleInfoForIntent(options: OpenFin.InfoForIntentOptions, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Responsible for returning information on which Intents are meant to handle a specific Context.
      * Must be overridden.
-     * @param { Context } context Data passed between entities and applications.
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleInfoForIntentsByContext
+     *
+     * @remarks Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.
+     *
+     * Whenever InteropClient.getInfoForIntentsByContext is called this function will fire. The context argument gives you access to the context that the client wants information on and clientIdentity is the identity of the client that made the call. Ideally here you would fetch the info for any intent that can handle and return it with the shape that the InteropClient.getInfoForIntentsByContext call is expecting.
+     *
+     * To make this call FDC3-Compliant it would need to return an array of AppIntents:
+     *
+     * ```js
+     * // [{
+     * //     intent: { name: "StartCall", displayName: "Call" },
+     * //     apps: [{ name: "Skype" }]
+     * // },
+     * // {
+     * //     intent: { name: "StartChat", displayName: "Chat" },
+     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+     * // }];
+     * ```
+     *
+     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).
+     *
+     * @param context Data passed between entities and applications.
+     * @param clientIdentity Identity of the Client making the request.
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async handleInfoForIntentsByContext(context, clientIdentity) {
+     *                 // Your code goes here.
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     handleInfoForIntentsByContext(context: OpenFin.Context | OpenFin.FindIntentsByContextOptions, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Responsible for resolving an Intent based on a specific Context.
      * Must be overridden.
-     * @param { ContextForIntent } contextForIntent Data passed between entities and applications.
-     * @param { ClientIdentity }  clientIdentity Identity of the Client making the request.
-     * @return { Promise<unknown> }
-     * @tutorial interop.handleFiredIntentForContext
+     *
+     * @remarks Whenever InteropClient.fireIntentForContext is called this function will fire. The contextForIntent argument
+     * gives you access to the context that will be resolved to an intent. It also can optionally contain any metadata relevant
+     * to resolving it, like a specific app the client wants the context to be handled by. The clientIdentity is the identity
+     * of the client that made the call.
+     *
+     * To make this call FDC3-Compliant it would need to return an IntentResolution:
+     *
+     * ```js
+     * // {
+     * //     intent: { name: "StartChat", displayName: "Chat" },
+     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+     * // }
+     * ```
+     *
+     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).
+     *
+     * @param contextForIntent Data passed between entities and applications.
+     * @param  clientIdentity Identity of the Client making the request.
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async handleFiredIntentForContext(contextForIntent, clientIdentity) {
+     *                 // Your code goes here.
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     handleFiredIntentForContext(contextForIntent: OpenFin.ContextForIntent, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.
      * @param clientIdentity
-     * @return { Promise<void> }
-     * @tutorial interop.clientDisconnected
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async clientDisconnected(clientIdentity) {
+     *                 const { uuid, name } = clientIdentity;
+     *                 console.log(`Client with identity ${uuid}/${name} has been disconnected`);
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     clientDisconnected(clientIdentity: OpenFin.ClientIdentity): Promise<void>;
     /**
      * Responsible for resolving an fdc3.open call.
      * Must be overridden.
-     * @param { Fdc3OpenOptions } fdc3OpenOptions fdc3.open options
-     * @param { ClientIdentity } clientIdentity Identity of the Client making the request.
+     * @param fdc3OpenOptions fdc3.open options
+     * @param clientIdentity Identity of the Client making the request.
      */
     fdc3HandleOpen({ app, context }: {
         app: TargetApp | AppIdentifier;
@@ -333,15 +479,15 @@ export declare class InteropBroker extends Base {
     /**
      * 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.
+     * @param  app AppIdentifier that was passed to fdc3.findInstances
+     * @param clientIdentity Identity of the Client making the request.
      */
     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.
+     * @param app AppIdentifier that was passed to fdc3.getAppMetadata
+     * @param clientIdentity Identity of the Client making the request.
      */
     fdc3HandleGetAppMetadata(app: AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
@@ -349,11 +495,31 @@ export declare class InteropBroker extends Base {
      * For FDC3 2.0 you would need to override this function and add the contextMetadata as
      * part of the Context object. Then would you need to call
      * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId
-     * @param { ClientIdentity } clientIdentity
-     * @param { string } handlerId
-     * @param { Context } context
-     * @returns { Promise<void> }
-     * @tutorial interopBroker.invokeContextHandler
+     * @param clientIdentity
+     * @param handlerId
+     * @param context
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async invokeContextHandler(options, clientIdentity) {
+     *                 return super.invokeContextHandler(clientIdentity, handlerId, {
+     *                     ...context,
+     *                     contextMetadata: {
+     *                         source: {
+     *                             appId: 'openfin-app',
+     *                             instanceId: '3D54D456D9HT0'
+     *                         }
+     *                     }
+     *                 });
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     invokeContextHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, context: OpenFin.Context): Promise<void>;
     /**
@@ -361,19 +527,43 @@ export declare class InteropBroker extends Base {
      * For FDC3 2.0 you would need to override this function and add the contextMetadata as
      * part of the Context object inside the Intent object. Then would you need to call
      * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId
-     * @param { ClientIdentity } ClientIdentity
-     * @param { string } handlerId
-     * @param { Context } context
-     * @returns { Promise<void> }
-     * @tutorial interopBroker.invokeIntentHandler
+     * @param ClientIdentity
+     * @param handlerId
+     * @param context
+     *
+     * @example
+     * ```js
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker) => {
+     *         class Override extends InteropBroker {
+     *             async invokeIntentHandler(options, clientIdentity) {
+     *                 const { context } = intent;
+     *                 return super.invokeIntentHandler(clientIdentity, handlerId, {
+     *                     ...intent,
+     *                     context: {
+     *                         ...context,
+     *                         contextMetadata: {
+     *                             source: {
+     *                                 appId: 'openfin-app',
+     *                                 instanceId: '3D54D456D9HT0'
+     *                             }
+     *                         }
+     *                     }
+     *                 });
+     *             }
+     *         }
+     *         return new Override();
+     *     }
+     * });
+     * ```
      */
     invokeIntentHandler(clientIdentity: OpenFin.ClientIdentity, handlerId: string, intent: OpenFin.Intent): Promise<void>;
     /**
      * Responsible for resolving fdc3.getInfo for FDC3 2.0
-     * Would need to return the optionalFeatures and appMetadata for the {@link ImplementationMetadata ImplementationMetadata}.
+     * Would need to return the optionalFeatures and appMetadata for the {@link https://fdc3.finos.org/docs/api/ref/Metadata#implementationmetadata ImplementationMetadata}.
      * Must be overridden.
      * @param clientIdentity
-     * @returns { Promise<ImplementationMetadata(2)> }
+     *
      */
     fdc3HandleGetInfo(payload: {
         fdc3Version: string;
@@ -383,8 +573,46 @@ export declare class InteropBroker extends Base {
      *
      * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating
      * an AppIdentifier.
-     * @return { Promise<Array<ClientInfo>> }
-     * @tutorial interop.getAllClientInfo
+     *
+     * @remarks FDC3 2.0 Note: When needing an instanceId to generate an AppIdentifier use this call to
+     * get the endpointId and use it as the instanceId. In the Example below we override handleFiredIntent
+     * and then call super.getAllClientInfo to generate the AppIdentifier for the IntentResolution.
+     *
+     *
+     * @example
+     * ```js
+     * // FDC3 2.0 Example:
+     * fin.Platform.init({
+     *     interopOverride: async (InteropBroker, ...args) => {
+     *         class Override extends InteropBroker {
+     *             async handleFiredIntent(intent) {
+     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });
+     *                 const platform = fin.Platform.getCurrentSync();
+     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });
+     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);
+     *
+     *                 const allClientInfo = await super.getAllClientInfo();
+     *
+     *                 const infoForTarget = allClientInfo.find((clientInfo) => {
+     *                     return clientInfo.uuid === 'platform-uuid' && clientInfo.name === 'intent-view';
+     *                 });
+     *
+     *                 const source = {
+     *                     appId: 'intent-view',
+     *                     instanceId: infoForTarget.endpointId
+     *                 }
+     *
+     *                 return {
+     *                     source,
+     *                     intent: intent.name
+     *                 }
+     *
+     *             }
+     *         }
+     *         return new Override(...args);
+     *     }
+     * });
+     * ```
      */
     getAllClientInfo(): Promise<Array<OpenFin.ClientInfo>>;
     decorateSnapshot(snapshot: OpenFin.Snapshot): OpenFin.Snapshot;