@openfin/core 33.76.36 → 33.76.38

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

@@ -1,502 +0,0 @@
-import type * as OpenFin from '../../OpenFin';
-import { Transport } from '../../transport/transport';
-import { Base } from '../base';
-/**
- * @PORTED
- * @typedef { object } Intent
- * @summary The combination of an action and a context that is passed to an application for resolution.
- * @property { string } name Name of the intent.
- * @property { Context } context Data associated with the intent
- */
-/**
- * @REMOVED
- * @typedef { object } Subscription
- * @summary Object returned when subscribing a handler.
- * @property { function } unsubscribe Function to unsubscribe the handler.
- */
-/**
- * @typedef { function } ContextHandler
- * @summary Subscription function for addContextHandler.
- */
-/**
- * @typedef { function } IntentHandler
- * @summary Subscription function for registerIntentHandler
- */
-/**
- * @PORTED
- * @typedef { object } ClientIdentity
- * @summary The Identity for a Channel Client. Includes endpointId to differentiate between different connections for an entity.
- * @property {string} uuid GUID of an application.
- * @property {string} name Name of an entity in an application.
- * @property {string} endpointId Unique differentiator for different Channel connections for an entity.
- */
-/**
- * @PORTED
- * @typedef { object } ContextGroupInfo
- * @summary Information for a Context Group. Contains metadata for displaying the group properly.
- * @property {string} id Name of the context group
- * @property {DisplayMetadata} displayMetadata Metadata for the Context Group. Contains the group's human-readable name, color, and an image, as defined by the Interop Broker.
- */
-/**
- * @PORTED
- * @typedef { object } DisplayMetadata
- * @summary The display data for a Context Group.
- * @property {string} name A user-readable name for this context group, e.g: `"Red"`
- * @property {string} [color] The color that should be associated within this context group when displaying this context group in a UI, e.g: `0xFF0000`.
- * @property {string} [glyph] A URL of an image that can be used to display this context group
- */
-/**
- * @PORTED
- * @typedef { object } Context
- * @summary Data passed between entities and applications.
- * @property {object} [id] An object containing string key-value pairs for the bulk of the data for the context. Differs between context types.
- * @property {string} [name] User-readable name for the incoming context.
- * @property {string} type Conserved type for the context (e.g. `instrument` or `country`)
- */
-/**
- * @REMOVED
- * @typedef { object } ContextForIntent
- * @summary Data passed between entities and applications, including an optional metadata.
- * @property {object} [id] An object containing string key-value pairs for the bulk of the data for the context. Differs between context types.
- * @property {string} [name] User-readable name for the incoming context.
- * @property {string} type Conserved type for the context (e.g. `instrument` or `country`)
- * @property {any} [metadata]
- */
-/**
- * @REMOVED
- * @typedef { object } SessionContextGroup
- * @summary An instance of a SessionContextGroup
- * @property {string} id The SessionContextGroup's id.
- * @property {setContext} setContext Sets a context of a certain type
- * @property {getCurrentContext} getCurrentContext Gets the currently set context of a certain type
- * @property {addContextHandler} addContextHandler Adds a handler for context change.
- */
-/**
- * @typedef {function} setContext
- * @summary A SessionContextGroup instance method for setting a context in the SessionContextGroup.
- * @param context The Context to be set.
- *
- */
-/**
- * @typedef {function} getCurrentContext
- * @summary A SessionContextGroup instance method for getting the current context of a certain type.
- * @param contextType The Context Type to get. If not specified the last contextType set would get used.
- *
- */
-/**
- * @typedef {function} addContextHandler
- * @summary A SessionContextGroup instance method for adding a handler for context change.
- * @param contextHandler The callback to be invoked. Is invoked when (a) the context changes or (b) immediately after getting created if the context is already set.
- * @param contextType The context type this handler should listen to. If not specified, a global handler for all context types will get created. Only one global handler is allowed per SessionContextGroup.
- *
- */
-/**
- * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}
- *
- * 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)}
- *
- */
-export declare class InteropClient extends Base {
-    #private;
-    /**
-     * @internal
-     */
-    constructor(wire: Transport, name: string, interopConfig?: OpenFin.InteropConfig);
-    /**
-     * 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)
-     * })
-     * ```
-     */
-    setContext(context: OpenFin.Context): Promise<void>;
-    /**
-     * 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')
-     * ```
-     */
-    addContextHandler(handler: OpenFin.ContextHandler, contextType?: string): Promise<{
-        unsubscribe: () => void;
-    }>;
-    /**
-     * 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)
-     *             })
-     *         })
-     * ```
-     */
-    getContextGroups(): Promise<OpenFin.ContextGroupInfo[]>;
-    /**
-     * 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)
-     *     })
-     * ```
-     */
-    joinContextGroup(contextGroupId: string, target?: OpenFin.Identity): Promise<void>;
-    /**
-     * 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)
-     *     })
-     * ```
-     */
-    removeFromContextGroup(target?: OpenFin.Identity): Promise<void>;
-    /**
-     * 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)
-     *     })
-     * ```
-     */
-    getAllClientsInContextGroup(contextGroupId: string): Promise<OpenFin.ClientIdentity[]>;
-    /**
-     * 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)
-     *     })
-     * ```
-     */
-    getInfoForContextGroup(contextGroupId: string): Promise<OpenFin.ContextGroupInfo | undefined>;
-    /**
-     * 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);
-     * })
-     * ```
-     */
-    fireIntent<T = unknown>(intent: OpenFin.Intent): Promise<T>;
-    /**
-     * 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();
-     * }
-     * ```
-     */
-    registerIntentHandler(handler: OpenFin.IntentHandler, intentName: string, options?: any): Promise<{
-        unsubscribe: () => Promise<void>;
-    }>;
-    /**
-     * 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');
-     * ```
-     */
-    getCurrentContext(contextType?: string): Promise<OpenFin.Context>;
-    /**
-     * 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');
-     * ```
-     */
-    getInfoForIntent<T = unknown>(options: OpenFin.InfoForIntentOptions): Promise<T>;
-    /**
-     * 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);
-     * })
-     * ```
-     */
-    getInfoForIntentsByContext<T = unknown>(context: OpenFin.Context): Promise<T>;
-    /**
-     * 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);
-     * })
-     * ```
-     */
-    fireIntentForContext<T = unknown>(context: OpenFin.ContextForIntent): Promise<T>;
-    /**
-     * 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');
-     * ```
-     */
-    joinSessionContextGroup(sessionContextGroupId: string): Promise<OpenFin.SessionContextGroup>;
-    /**
-     * 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);
-     * ```
-     */
-    onDisconnection(listener: OpenFin.InteropClientOnDisconnectionListener): Promise<void>;
-    static ferryFdc3Call(interopClient: OpenFin.InteropClient, action: string, payload?: any): Promise<any>;
-}