@openfin/core 38.81.34 → 38.81.37

package/out/fdc3.d.ts

@@ -0,0 +1,1964 @@
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * Identifies an application, or instance of an application, and is used to target FDC3 API calls, such as `fdc3.open` or `fdc3.raiseIntent` at specific applications or application instances.
+ *
+ * Will always include at least an `appId` field, which uniquely identifies a specific app.
+ *
+ * If the `instanceId` field is set then the `AppMetadata` object represents a specific instance of the application that may be addressed using that Id.
+ */
+declare interface AppIdentifier {
+    /** The unique application identifier located within a specific application directory instance. An example of an appId might be 'app@sub.root' */
+    readonly appId: string;
+    /** An optional instance identifier, indicating that this object represents a specific instance of the application described.*/
+    readonly instanceId?: string;
+}
+
+/**
+ * An interface that relates an intent to apps
+ */
+declare interface AppIntent {
+    readonly intent: IntentMetadata;
+    readonly apps: Array<AppMetadata>;
+}
+
+/**
+ * An interface that relates an intent to apps
+ */
+declare interface AppIntent_2 {
+    /** Details of the intent whose relationship to resolving applications is being described. */
+    readonly intent: IntentMetadata_2;
+    /** Details of applications that can resolve the intent. */
+    readonly apps: Array<AppMetadata_2>;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2019 FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * App definition as provided by the application directory
+ */
+declare interface AppMetadata {
+    /** The unique app name that can be used with the open and raiseIntent calls. */
+    readonly name: string;
+    /** The unique application identifier located within a specific application directory instance. An example of an appId might be 'app@sub.root' */
+    readonly appId?: string;
+    /** The Version of the application. */
+    readonly version?: string;
+    /** A more user-friendly application title that can be used to render UI elements  */
+    readonly title?: string;
+    /**  A tooltip for the application that can be used to render UI elements */
+    readonly tooltip?: string;
+    /** A longer, multi-paragraph description for the application that could include markup */
+    readonly description?: string;
+    /** A list of icon URLs for the application that can be used to render UI elements */
+    readonly icons?: Array<string>;
+    /** A list of image URLs for the application that can be used to render UI elements */
+    readonly images?: Array<string>;
+}
+
+/**
+ * Extends an `AppIdentifier`, describing an application or instance of an application, with additional descriptive metadata that is usually provided by an FDC3 App Directory that the desktop agent connects to.
+ *
+ * The additional information from an app directory can aid in rendering UI elements, such as a launcher menu or resolver UI. This includes a title, description, tooltip and icon and screenshot URLs.
+ *
+ * Note that as `AppMetadata` instances are also `AppIdentifiers` they may be passed to the `app` argument of `fdc3.open`, `fdc3.raiseIntent` etc.
+ */
+declare interface AppMetadata_2 extends AppIdentifier {
+    /**
+     The 'friendly' app name.
+     This field was used with the `open` and `raiseIntent` calls in FDC3 <2.0, which now require an `AppIdentifier` wth `appId` set.
+     Note that for display purposes the `title` field should be used, if set, in preference to this field.
+     */
+    readonly name?: string;
+    /** The Version of the application. */
+    readonly version?: string;
+    /** An optional set of, implementation specific, metadata fields that can be used to disambiguate instances, such as a window title or screen position. Must only be set if `instanceId` is set. */
+    readonly instanceMetadata?: Record<string, any>;
+    /** A more user-friendly application title that can be used to render UI elements  */
+    readonly title?: string;
+    /**  A tooltip for the application that can be used to render UI elements */
+    readonly tooltip?: string;
+    /** A longer, multi-paragraph description for the application that could include markup */
+    readonly description?: string;
+    /** A list of icon URLs for the application that can be used to render UI elements */
+    readonly icons?: Array<Icon>;
+    /** Images representing the app in common usage scenarios that can be used to render UI elements  */
+    readonly screenshots?: Array<Image_2>;
+    /** The type of output returned for any intent specified during resolution. May express a particular context type (e.g. "fdc3.instrument"), channel (e.g. "channel") or a channel that will receive a specified type (e.g. "channel<fdc3.instrument>"). */
+    readonly resultType?: string | null;
+}
+
+/**
+ * Object representing a context channel.
+ */
+declare interface Channel {
+    /**
+     * Constant that uniquely identifies this channel.
+     */
+    readonly id: string;
+    /**
+     * Uniquely defines each channel type.
+     */
+    readonly type: string;
+    /**
+     * Channels may be visualized and selectable by users. DisplayMetadata may be used to provide hints on how to see them.
+     * For app channels, displayMetadata would typically not be present
+     */
+    readonly displayMetadata?: DisplayMetadata;
+    /**
+     * Broadcasts the given context on this channel. This is equivalent to joining the channel and then calling the
+     * top-level FDC3 `broadcast` function.
+     *
+     * Note that this function can be used without first joining the channel, allowing applications to broadcast on
+     * channels that they aren't a member of.
+     *
+     * Channel implementations should ensure that context messages broadcast by an application on a channel should
+     * not be delivered back to that same application if they are joined to the channel.
+     *
+     * `Error` with a string from the `ChannelError` enumeration.
+     */
+    broadcast(context: Context): void;
+    /**
+     * Returns the last context that was broadcast on this channel. All channels initially have no context, until a
+     * context is broadcast on the channel. If there is not yet any context on the channel, this method
+     * will return `null`.
+     *
+     * The context of a channel will be captured regardless of how the context is broadcasted on this channel - whether
+     * using the top-level FDC3 `broadcast` function, or using the channel-level {@link broadcast} function on this
+     * object.
+     *
+     * Optionally a {@link contextType} can be provided, in which case the current context of the matching type will
+     * be returned (if any). Desktop agent implementations may decide to record contexts by type, in which case it will
+     * be possible to get the most recent context of the type specified, but this is not guaranteed.
+     *
+     * `Error` with a string from the `ChannelError` enumeration.
+     */
+    getCurrentContext(contextType?: string): Promise<Context | null>;
+    /**
+     * Adds a listener for incoming contexts whenever a broadcast happens on this channel.
+     * @deprecated use `addContextListener(null, handler)` instead of `addContextListener(handler)`.
+     */
+    addContextListener(handler: ContextHandler): Listener;
+    /**
+     * Adds a listener for incoming contexts of the specified context type whenever a broadcast happens on this channel.
+     */
+    addContextListener(contextType: string | null, handler: ContextHandler): Listener;
+}
+
+/**
+ * Represents a context channel that applications can use to send and receive
+ * context data.
+ *
+ * Please note that There are differences in behavior when you interact with a
+ * User channel via the `DesktopAgent` interface and the `Channel` interface.
+ * Specifically, when 'joining' a User channel or adding a context listener
+ * when already joined to a channel via the `DesktopAgent` interface, existing
+ * context (matching the type of the context listener) on the channel is
+ * received by the context listener immediately. Whereas, when a context
+ * listener is added via the Channel interface, context is not received
+ * automatically, but may be retrieved manually via the `getCurrentContext()`
+ * function.
+ */
+declare interface Channel_2 {
+    /**
+     * Constant that uniquely identifies this channel.
+     */
+    readonly id: string;
+    /**
+     * Uniquely defines each channel type.
+     * Can be "user", "app" or "private".
+     */
+    readonly type: 'user' | 'app' | 'private';
+    /**
+     * Channels may be visualized and selectable by users. DisplayMetadata may be used to provide hints on how to see them.
+     * For App channels, displayMetadata would typically not be present.
+     */
+    readonly displayMetadata?: DisplayMetadata_2;
+    /**
+     * Broadcasts a context on the channel. This function can be used without first joining the channel, allowing applications to broadcast on both App Channels and User Channels that they aren't a member of.
+     *
+     * If the broadcast is denied by the channel or the channel is not available, the promise will be rejected with an `Error` with a `message` string from the `ChannelError` enumeration.
+     *
+     * Channel implementations should ensure that context messages broadcast by an application on a channel should not be delivered back to that same application if they are joined to the channel.
+     *
+     * If you are working with complex context types composed of other simpler types (as recommended by the FDC3 Context Data specification) then you should broadcast each individual type (starting with the simpler types, followed by the complex type) that you want other apps to be able to respond to. Doing so allows applications to filter the context types they receive by adding listeners for specific context types.
+     *
+     * If an application attempts to broadcast an invalid context argument the Promise returned by this function should reject with the `ChannelError.MalformedContext` error.
+     */
+    broadcast(context: Context_2): Promise<void>;
+    /**
+     * When a `contextType`_` is provided, the most recent context matching the type will be returned, or `null` if no matching context is found.
+     *
+     * If no `contextType` is provided, the most recent context that was broadcast on the channel - regardless of type - will be returned.  If no context has been set on the channel, it will return `null`.
+     *
+     * It is up to the specific Desktop Agent implementation whether and how recent contexts are stored. For example, an implementation could store context history for a channel in a single array and search through the array for the last context matching a provided type, or context could be maintained as a dictionary keyed by context types. An implementation could also choose not to support context history, in which case this method will return `null` for any context type not matching the type of the most recent context.
+     *
+     * If getting the current context fails, the promise will be rejected with an `Error` with a `message` string from the `ChannelError` enumeration.
+     */
+    getCurrentContext(contextType?: string): Promise<Context_2 | null>;
+    /**
+     * Adds a listener for incoming contexts of the specified _context type_ whenever a broadcast happens on this channel.
+     *
+     * If, when this function is called, the channel already contains context that would be passed to the listener it is NOT called or passed this context automatically (this behavior differs from that of the [`fdc3.addContextListener`](DesktopAgent#addcontextlistener) function). Apps wishing to access to the current context of the channel should instead call the `getCurrentContext(contextType)` function.
+     *
+     * Optional metadata about each context message received, including the app that originated the message, SHOULD be provided by the desktop agent implementation.
+     */
+    addContextListener(contextType: string | null, handler: ContextHandler_2): Promise<Listener_2>;
+    /**
+     * @deprecated use `addContextListener(null, handler)` instead of `addContextListener(handler)`.
+     */
+    addContextListener(handler: ContextHandler_2): Promise<Listener_2>;
+}
+
+declare enum ChannelError {
+    NoChannelFound = "NoChannelFound",
+    AccessDenied = "AccessDenied",
+    CreationFailed = "CreationFailed"
+}
+
+declare enum ChannelError_2 {
+    /** Returned if the specified channel is not found when attempting to join a channel via the `joinUserChannel` function  of the DesktopAgent (`fdc3`).*/
+    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. */
+    AccessDenied = "AccessDenied",
+    /** SHOULD be returned when a channel cannot be created or retrieved via the `getOrCreateChannel` method of the DesktopAgent (`fdc3`).*/
+    CreationFailed = "CreationFailed",
+    /** Returned if a call to the `broadcast` functions is made with an invalid context argument. Contexts should be Objects with at least a `type` field that has a `string` value.*/
+    MalformedContext = "MalformedContext"
+}
+
+declare interface Chart {
+    instruments: InstrumentElement[];
+    otherConfig?: {
+        [key: string]: any;
+    };
+    range?: TimeRangeObject;
+    style?: Style;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface ChatInitSettings {
+    chatName?: string;
+    initMessage?: string;
+    members?: ContactListObject;
+    options?: any;
+    type: any;
+    [property: string]: any;
+}
+
+declare interface Contact {
+    id: ContactID;
+    type: string;
+    name?: string;
+}
+
+declare interface Contact_2 {
+    id: TentacledID;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface ContactElement {
+    id: FluffyID;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface ContactID {
+    email?: string;
+    FDS_ID?: string;
+}
+
+declare interface ContactList {
+    contacts: Contact[];
+    type: string;
+    id?: {
+        [key: string]: string;
+    };
+    name?: string;
+}
+
+declare interface ContactList_2 {
+    contacts: ContactElement[];
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface ContactListObject {
+    contacts: ContactElement[];
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface Context {
+    id?: {
+        [key: string]: string;
+    };
+    name?: string;
+    type: string;
+}
+
+declare interface Context_2 {
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    type: string;
+    [property: string]: any;
+}
+
+declare type ContextHandler = (context: Context) => void;
+
+/**
+ * Describes a callback that handles a context event.
+ * Used when attaching listeners for context broadcasts.
+ *
+ * Optional metadata about the context message, including the app that originated
+ * the message, SHOULD be provided by the desktop agent implementation.
+ */
+declare type ContextHandler_2 = (context: Context_2, metadata?: ContextMetadata) => void;
+
+/**
+ * Metadata relating to a context or intent and context received through the
+ * `addContextListener` and `addIntentListener` functions.
+ *
+ * @experimental Introduced in FDC3 2.0 and may be refined by further changes outside the normal FDC3 versioning policy.
+ */
+declare interface ContextMetadata {
+    /** Identifier for the app instance that sent the context and/or intent.
+     *
+     *  @experimental
+     */
+    readonly source: AppIdentifier;
+}
+
+declare type ContextType = ContextTypes | string;
+
+declare type ContextType_2 = ContextTypes_2 | string;
+
+declare enum ContextTypes {
+    Contact = "fdc3.contact",
+    ContactList = "fdc3.contactList",
+    Country = "fdc3.country",
+    Instrument = "fdc3.instrument",
+    Organization = "fdc3.organization",
+    Portfolio = "fdc3.portfolio",
+    Position = "fdc3.position"
+}
+
+declare enum ContextTypes_2 {
+    Chart = "fdc3.chart",
+    ChatInitSettings = "fdc3.chat.initSettings",
+    Contact = "fdc3.contact",
+    ContactList = "fdc3.contactList",
+    Country = "fdc3.country",
+    Currency = "fdc3.currency",
+    Email = "fdc3.email",
+    Instrument = "fdc3.instrument",
+    InstrumentList = "fdc3.instrumentList",
+    Organization = "fdc3.organization",
+    Portfolio = "fdc3.portfolio",
+    Position = "fdc3.position",
+    Nothing = "fdc3.nothing",
+    TimeRange = "fdc3.timerange",
+    Valuation = "fdc3.valuation"
+}
+
+declare class Convert {
+    static toContext(json: string): Context;
+    static contextToJson(value: Context): string;
+    static toContact(json: string): Contact;
+    static contactToJson(value: Contact): string;
+    static toContactList(json: string): ContactList;
+    static contactListToJson(value: ContactList): string;
+    static toInstrument(json: string): Instrument;
+    static instrumentToJson(value: Instrument): string;
+    static toInstrumentList(json: string): InstrumentList;
+    static instrumentListToJson(value: InstrumentList): string;
+    static toCountry(json: string): Country;
+    static countryToJson(value: Country): string;
+    static toOrganization(json: string): Organization;
+    static organizationToJson(value: Organization): string;
+    static toPortfolio(json: string): Portfolio;
+    static portfolioToJson(value: Portfolio): string;
+    static toPosition(json: string): Position;
+    static positionToJson(value: Position): string;
+}
+
+declare class Convert_2 {
+    static toChart(json: string): Chart;
+    static chartToJson(value: Chart): string;
+    static toChatInitSettings(json: string): ChatInitSettings;
+    static chatInitSettingsToJson(value: ChatInitSettings): string;
+    static toContact(json: string): Contact_2;
+    static contactToJson(value: Contact_2): string;
+    static toContactList(json: string): ContactList_2;
+    static contactListToJson(value: ContactList_2): string;
+    static toContext(json: string): Context_2;
+    static contextToJson(value: Context_2): string;
+    static toCountry(json: string): Country_2;
+    static countryToJson(value: Country_2): string;
+    static toCurrency(json: string): Currency;
+    static currencyToJson(value: Currency): string;
+    static toEmail(json: string): Email;
+    static emailToJson(value: Email): string;
+    static toInstrument(json: string): Instrument_2;
+    static instrumentToJson(value: Instrument_2): string;
+    static toInstrumentList(json: string): InstrumentList_2;
+    static instrumentListToJson(value: InstrumentList_2): string;
+    static toNothing(json: string): Nothing;
+    static nothingToJson(value: Nothing): string;
+    static toOrganization(json: string): Organization_2;
+    static organizationToJson(value: Organization_2): string;
+    static toPortfolio(json: string): Portfolio_2;
+    static portfolioToJson(value: Portfolio_2): string;
+    static toPosition(json: string): Position_2;
+    static positionToJson(value: Position_2): string;
+    static toTimeRange(json: string): TimeRange;
+    static timeRangeToJson(value: TimeRange): string;
+    static toValuation(json: string): Valuation;
+    static valuationToJson(value: Valuation): string;
+}
+
+declare interface Country {
+    id: CountryID;
+    type: string;
+    name?: string;
+}
+
+declare interface Country_2 {
+    id: CountryID_2;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface CountryID {
+    ISOALPHA2?: string;
+    ISOALPHA3?: string;
+}
+
+declare interface CountryID_2 {
+    COUNTRY_ISOALPHA2?: string;
+    COUNTRY_ISOALPHA3?: string;
+    ISOALPHA2?: string;
+    ISOALPHA3?: string;
+    [property: string]: any;
+}
+
+declare interface Currency {
+    id: CurrencyID;
+    name?: string;
+    type: string;
+    [property: string]: any;
+}
+
+declare interface CurrencyID {
+    CURRENCY_ISOCODE?: string;
+    [property: string]: any;
+}
+
+/**
+ * A Desktop Agent is a desktop component (or aggregate of components) that serves as a
+ * launcher and message router (broker) for applications in its domain.
+ *
+ * A Desktop Agent can be connected to one or more App Directories and will use directories for application
+ * identity and discovery. Typically, a Desktop Agent will contain the proprietary logic of
+ * a given platform, handling functionality like explicit application interop workflows where
+ * security, consistency, and implementation requirements are proprietary.
+ */
+declare interface DesktopAgent {
+    /**
+     * Launches an app by target, which can be optionally a string like a name, or an AppMetadata object.
+     *
+     * If a Context object is passed in, this object will be provided to the opened application via a contextListener.
+     * The Context argument is functionally equivalent to opening the target app with no context and broadcasting the context directly to it.
+     *
+     * If opening errors, it returns an `Error` with a string from the `OpenError` enumeration.
+     *
+     *  ```javascript
+     *     //no context and string as target
+     *     agent.open('myApp');
+     *     //no context and AppMetadata object as target
+     *     agent.open({name: 'myApp', title: 'The title for the application myApp.', description: '...'});
+     *     //with context
+     *     agent.open('myApp', context);
+     * ```
+     */
+    open(app: TargetApp, context?: Context): Promise<void>;
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context.
+     *
+     * findIntent is effectively granting programmatic access to the Desktop Agent's resolver.
+     * A promise resolving to the intent, its metadata and metadata about the apps that registered it is returned.
+     * This can be used to raise the intent against a specific app.
+     *
+     * If the resolution fails, the promise will return an `Error` with a string from the `ResolveError` enumeration.
+     *
+     * ```javascript
+     * // I know 'StartChat' exists as a concept, and want to know more about it ...
+     * const appIntent = await agent.findIntent("StartChat");
+     *
+     * // returns a single AppIntent:
+     * // {
+     * //     intent: { name: "StartChat", displayName: "Chat" },
+     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+     * // }
+     *
+     * // raise the intent against a particular app
+     * await agent.raiseIntent(appIntent.intent.name, context, appIntent.apps[0].name);
+     * ```
+     */
+    findIntent(intent: string, context?: Context): Promise<AppIntent>;
+    /**
+     * Find all the avalable intents for a particular context.
+     *
+     * findIntents is effectively granting programmatic access to the Desktop Agent's resolver.
+     * A promise resolving to all the intents, their metadata and metadata about the apps that registered it is returned,
+     * based on the context types the intents have registered.
+     *
+     * If the resolution fails, the promise will return an `Error` with a string from the `ResolveError` enumeration.
+     *
+     * ```javascript
+     * // I have a context object, and I want to know what I can do with it, hence, I look for for intents...
+     * const appIntents = await agent.findIntentsByContext(context);
+     *
+     * // returns for example:
+     * // [{
+     * //     intent: { name: "StartCall", displayName: "Call" },
+     * //     apps: [{ name: "Skype" }]
+     * // },
+     * // {
+     * //     intent: { name: "StartChat", displayName: "Chat" },
+     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+     * // }];
+     *
+     * // select a particular intent to raise
+     * const startChat = appIntents[1];
+     *
+     * // target a particular app
+     * const selectedApp = startChat.apps[0];
+     *
+     * // raise the intent, passing the given context, targeting the app
+     * await agent.raiseIntent(startChat.intent.name, context, selectedApp.name);
+     * ```
+     */
+    findIntentsByContext(context: Context): Promise<Array<AppIntent>>;
+    /**
+     * Publishes context to other apps on the desktop.
+     *
+     * DesktopAgent implementations should ensure that context messages broadcast to a channel
+     * by an application joined to it should not be delivered back to that same application.
+     *
+     * ```javascript
+     *  agent.broadcast(context);
+     * ```
+     */
+    broadcast(context: Context): void;
+    /**
+     * Raises an intent to the desktop agent to resolve.
+     * ```javascript
+     * //Find apps to resolve an intent to start a chat with a given contact
+     * const appIntent = await fdc3.findIntent("StartChat", context);
+     * //use the returned AppIntent object to target one of the returned chat apps with the context
+     * await fdc3.raiseIntent("StartChat", context, appIntent.apps[0].name);
+     * //or use one of the AppMetadata objects returned in the AppIntent object's 'apps' array
+     * await fdc3.raiseIntent("StartChat", context, appMetadata);
+     * ```
+     */
+    raiseIntent(intent: string, context: Context, app?: TargetApp): Promise<IntentResolution>;
+    /**
+     * Raises a context to the desktop agent to resolve with one of the possible Intents for that context.
+     * ```javascript
+     * await fdc3.raiseIntentForContext(context);
+     * ```
+     */
+    raiseIntentForContext(context: Context, app?: TargetApp): Promise<IntentResolution>;
+    /**
+     * Adds a listener for incoming Intents from the Agent.
+     */
+    addIntentListener(intent: string, handler: ContextHandler): Listener;
+    /**
+     * Adds a listener for incoming context broadcast from the Desktop Agent.
+     * @deprecated use `addContextListener(null, handler)` instead of `addContextListener(handler)`.
+     */
+    addContextListener(handler: ContextHandler): Listener;
+    /**
+     * Adds a listener for the broadcast of a specific type of context object.
+     */
+    addContextListener(contextType: string | null, handler: ContextHandler): Listener;
+    /**
+     * Retrieves a list of the System channels available for the app to join
+     */
+    getSystemChannels(): Promise<Array<Channel>>;
+    /**
+     * Joins the app to the specified channel.
+     * An app can only be joined to one channel at a time.
+     * Rejects with error if the channel is unavailable or the join request is denied.
+     * `Error` with a string from the `ChannelError` enumeration.
+     */
+    joinChannel(channelId: string): Promise<void>;
+    /**
+     * Returns a channel with the given identity. Either stands up a new channel or returns an existing channel.
+     *
+     * It is up to applications to manage how to share knowledge of these custom channels across windows and to manage
+     * channel ownership and lifecycle.
+     *
+     * `Error` with a string from the `ChannelError` enumeration.
+     */
+    getOrCreateChannel(channelId: string): Promise<Channel>;
+    /**
+     * Returns the `Channel` object for the current channel membership.
+     *
+     * Returns `null` if the app is not joined to a channel.
+     */
+    getCurrentChannel(): Promise<Channel | null>;
+    /**
+     * Removes the app from any channel membership.
+     *
+     * Context broadcast and listening through the top-level `fdc3.broadcast` and `fdc3.addContextListener` will be
+     * in a no-op when the app is not on a channel.
+     */
+    leaveCurrentChannel(): Promise<void>;
+    /**
+     * Retrieves information about the FDC3 Desktop Agent implementation, such as
+     * the implemented version of the FDC3 specification and the name of the implementation
+     * provider.
+     */
+    getInfo(): ImplementationMetadata;
+}
+
+/**
+ * A Desktop Agent is a desktop component (or aggregate of components) that serves as a
+ * launcher and message router (broker) for applications in its domain.
+ *
+ * A Desktop Agent can be connected to one or more App Directories and will use directories for application
+ * identity and discovery. Typically, a Desktop Agent will contain the proprietary logic of
+ * a given platform, handling functionality like explicit application interop workflows where
+ * security, consistency, and implementation requirements are proprietary.
+ */
+declare interface DesktopAgent_2 {
+    /**
+     * Launches an app, specified via an `AppIdentifier` object.
+     *
+     * The `open` method differs in use from `raiseIntent`.  Generally, it should be used when the target application is known but there is no specific intent.  For example, if an application is querying the App Directory, `open` would be used to open an app returned in the search results.
+     *
+     * **Note**, if the intent, context and target app name are all known, it is recommended to instead use `raiseIntent` with the `target` argument.
+     *
+     * If a Context object is passed in, this object will be provided to the opened application via a contextListener. The Context argument is functionally equivalent to opening the target app with no context and broadcasting the context directly to it.
+     *
+     * Returns an `AppIdentifier` object with the `instanceId` field set identifying the instance of the application opened by this call.
+     *
+     * If an error occurs while opening the app, the promise MUST be rejected with an `Error` Object with a `message` chosen from the `OpenError` enumeration.
+     *
+     * ```javascript
+     * //Open an app without context, using an AppIdentifier object to specify the target by `appId`.
+     * let appIdentifier = {appId: 'myApp-v1.0.1'};
+     * let instanceIdentifier = await fdc3.open(appIdentifier);
+     *
+     * //Open an app with context
+     * let instanceIdentifier = await fdc3.open(appIdentifier, context);
+     * ```
+     */
+    open(app: AppIdentifier, context?: Context_2): Promise<AppIdentifier>;
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context and/or a desired result context type.
+     *
+     * `findIntent` is effectively granting programmatic access to the Desktop Agent's resolver.
+     * It returns a promise resolving to the intent, its metadata and metadata about the apps and app instances that registered that intent.
+     * This can be used to raise the intent against a specific app or app instance.
+     *
+     * If the resolution fails, the promise MUST be rejected with an `Error` Object with a `message` chosen from the `ResolveError` enumeration. This includes the case where no apps are found that resolve the intent, when the `ResolveError.NoAppsFound` message should be used, and when an invalid context object is passed as an argument, when the `ResolveError.MalformedContext` message should be used.
+     *
+     * Result types may be a type name, the string "channel" (which indicates that the app
+     * will return a channel) or a string indicating a channel that returns a specific type,
+     * e.g. "channel<fdc3.instrument>".
+     *
+     * If intent resolution to an app returning a channel is requested, the desktop agent
+     * MUST include both apps that are registered as returning a channel and those registered
+     * as returning a channel with a specific type in the response.
+     *
+     * ```javascript
+     * // I know 'StartChat' exists as a concept, and want to know which apps can resolve it ...
+     * const appIntent = await fdc3.findIntent("StartChat");
+     *
+     * // returns a single AppIntent:
+     * // {
+     * //     intent: { name: "StartChat" },
+     * //   apps: [
+     * //    { appId: "Skype" },
+     * //    { appId: "Symphony" },
+     * //    { appId: "Slack" }
+     * //   ]
+     * // }
+     *
+     * // raise the intent against a particular app
+     * await fdc3.raiseIntent(appIntent.intent.name, context, appIntent.apps[0]);
+     *
+     * //later, we want to raise 'StartChat' intent again
+     * const appIntent = await fdc3.findIntent("StartChat");
+     * // returns an AppIntent, but with multiple options for resolution,
+     * // which includes an existing instance of an application:
+     * // {
+     * //   intent: { name: "StartChat" },
+     * //   apps: [
+     * //    { appId: "Skype" },
+     * //    { appId: "Symphony" },
+     * //    { appId: "Symphony", instanceId: "93d2fe3e-a66c-41e1-b80b-246b87120859" },
+     * //    { appId: "Slack" }
+     * //   ]
+     * ```
+     *
+     * An optional input context object and result type may be specified, which the resolver MUST use to filter the returned applications such that each supports the specified input and result types.
+     *
+     * ```javascript
+     * const appIntent = await fdc3.findIntent("StartChat", contact);
+     *
+     * // returns only apps that support the type of the specified input context:
+     * // {
+     * //     intent: { name: "StartChat" },
+     * //     apps: [{ appId: "Symphony" }]
+     * // }
+     *
+     * const appIntent = await fdc3.findIntent("ViewContact", contact, "fdc3.ContactList");
+     *
+     * // returns only apps that return the specified result Context type:
+     * // {
+     * //     intent: { name: "ViewContact" },
+     * //     apps: { appId: "MyCRM", resultType: "fdc3.ContactList"}]
+     * // }
+     *
+     * const appIntent = await fdc3.findIntent("QuoteStream", instrument, "channel<fdc3.Quote>");
+     *
+     * // returns only apps that return a channel which will receive the specified input and result types:
+     * // {
+     * //     intent: { name: "QuoteStream" },
+     * //     apps: [{ appId: "MyOMS", resultType: "channel<fdc3.Quote>"}]
+     * // }
+     * ```
+     */
+    findIntent(intent: string, context?: Context_2, resultType?: string): Promise<AppIntent_2>;
+    /**
+     * Find all the available intents for a particular context, and optionally a desired result context type.
+     *
+     * `findIntentsByContext` is effectively granting programmatic access to the Desktop Agent's resolver.
+     * It returns a promise resolving to an `AppIntent` which provides details of the intent, its metadata and metadata about the apps and app instances that are registered to handle it. This can be used to raise the intent against a specific app or app instance.
+     *
+     * If the resolution fails, the promise MUST be rejected with an `Error` Object with a `message` chosen from the `ResolveError` enumeration. This includes the case where no intents with associated apps are found, when the `ResolveError.NoAppsFound` message should be used, and when an invalid context object is passed as an argument, when the `ResolveError.MalformedContext` message should be used.
+     *
+     * The optional `resultType` argument may be a type name, the string "channel" (which indicates that the app
+     * should return a channel) or a string indicating a channel that returns a specific type,
+     * e.g. "channel<fdc3.instrument>". If intent resolution to an app returning a channel is requested without
+     * a specified context type, the desktop agent MUST also include apps that are registered as returning a
+     * channel with a specific type in the response.
+     *
+     * ```javascript
+     * // I have a context object, and I want to know what I can do with it, hence, I look for intents and apps to resolve them...
+     * const appIntents = await fdc3.findIntentsByContext(context);
+     *
+     * // returns for example:
+     * // [
+     * //   {
+     * //     intent: { name: "StartCall" },
+     * //     apps: [{ name: "Skype" }]
+     * //   },
+     * //   {
+     * //     intent: { name: "StartChat" },
+     * //     apps: [
+     * //       { appId: "Skype" },
+     * //       { appId: "Symphony" },
+     * //       { appId: "Symphony", instanceId: "93d2fe3e-a66c-41e1-b80b-246b87120859" },
+     * //       { appId: "Slack" }
+     * //     ]
+     * //   }
+     * // ];
+     *
+     * // or I look for only intents that are resolved by apps returning a particular result type
+     * const appIntentsForType = await fdc3.findIntentsByContext(context, "fdc3.ContactList");
+     * // returns for example:
+     * // [{
+     * //     intent: { name: "ViewContact" },
+     * //     apps: [{ appId: "MyCRM", resultType: "fdc3.ContactList"}]
+     * // }];
+     *
+     * // select a particular intent to raise
+     * const resolvedIntent = appIntents[1];
+     *
+     * // target a particular app or instance
+     * const selectedApp = resolvedIntent.apps[2];
+     *
+     * // raise the intent, passing the given context, targeting the app or app instance
+     * await fdc3.raiseIntent(startChat.intent.name, context, selectedApp);
+     * ```
+     */
+    findIntentsByContext(context: Context_2, resultType?: string): Promise<Array<AppIntent_2>>;
+    /**
+     * Find all the available instances for a particular application.
+     *
+     * If there are no instances of the specified application the returned promise should resolve to an empty array.
+     *
+     * If the request fails for another reason, the promise MUST be rejected with an `Error` Object with a `message` chosen from the `ResolveError` enumeration.
+     *
+     * ```javascript
+     * // Retrieve a list of instances of an application
+     * let instances = await fdc3.findInstances({appId: "MyAppId"});
+     *
+     * // Target a raised intent at a specific instance
+     * let resolution = fdc3.raiseIntent("ViewInstrument", context, instances[0]);
+     * ```
+     * @param app
+     */
+    findInstances(app: AppIdentifier): Promise<Array<AppIdentifier>>;
+    /**
+     * Publishes context to other apps on the desktop.  Calling `broadcast` at the `DesktopAgent` scope will push the context to whatever _User Channel_ the app is joined to.  If the app is not currently joined to a channel, calling `fdc3.broadcast` will have no effect.  Apps can still directly broadcast and listen to context on any channel via the methods on the `Channel` class.
+     *
+     * DesktopAgent implementations should ensure that context messages broadcast to a channel by an application joined to it should not be delivered back to that same application.
+     *
+     * If you are working with complex context types composed of other simpler types then you should broadcast
+     * each individual type (starting with the simpler types, followed by the complex type) that you want other
+     * apps to be able to respond to. Doing so allows applications to filter the context types they receive by
+     * adding listeners for specific context types.
+     *
+     * If an application attempts to broadcast an invalid context argument the Promise returned by this function should reject with the `ChannelError.MalformedContext` error.
+     *
+     * ```javascript
+     * const instrument = {
+     *   type: 'fdc3.instrument',
+     *   id: {
+     *     ticker: 'AAPL'
+     *   }
+     * };
+     * fdc3.broadcast(context);
+     * ```
+     */
+    broadcast(context: Context_2): Promise<void>;
+    /**
+     * Raises a specific intent for resolution against apps registered with the desktop agent.
+     *
+     * The desktop agent MUST resolve the correct app to target based on the provided intent name and context data. If multiple matching apps are found, the user MAY be presented with a Resolver UI allowing them to pick one, or another method of Resolution applied to select an app.
+     * Alternatively, the specific app or app instance to target can also be provided. A list of valid target applications and instances can be retrieved via `findIntent`.
+     *
+     * If a target app for the intent cannot be found with the criteria provided or the user either closes the resolver UI or otherwise cancels resolution, the promise MUST be rejected with an `Error` object with a `message` chosen from the `ResolveError` enumeration. If a specific target `app` parameter was set, but either the app or app instance is not available, the promise MUST be rejected with an `Error` object with either the `ResolveError.TargetAppUnavailable` or `ResolveError.TargetInstanceUnavailable` string as its `message`. If an invalid context object is passed as an argument the promise MUST be rejected with an `Error` object with the `ResolveError.MalformedContext` string as its `message`.
+     *
+     * If you wish to raise an Intent without a context, use the `fdc3.nothing` context type. This type exists so that apps can explicitly declare support for raising an intent without context.
+     *
+     * Returns an `IntentResolution` object with details of the app instance that was selected (or started) to respond to the intent.
+     *
+     * Issuing apps may optionally wait on the promise that is returned by the `getResult()` member of the `IntentResolution`. This promise will resolve when the _receiving app's_ intent handler function returns and resolves a promise. The Desktop Agent resolves the issuing app's promise with the Context object, Channel object or void that is provided as resolution within the receiving app. The Desktop Agent MUST reject the issuing app's promise, with a string from the `ResultError` enumeration, if: (1) the intent handling function's returned promise rejects, (2) the intent handling function doesn't return a valid response (a promise or void), or (3) the returned promise resolves to an invalid type.
+     *
+     * ```javascript
+     * // raise an intent for resolution by the desktop agent
+     * // a resolver UI may be displayed if more than one application can resolve the intent
+     * await fdc3.raiseIntent("StartChat", context);
+     *
+     * // or find apps to resolve an intent to start a chat with a given contact
+     * const appIntent = await fdc3.findIntent("StartChat", context);
+
+     * // use the metadata of an app or app instance to describe the target app for the intent
+     * await fdc3.raiseIntent("StartChat", context, appIntent.apps[0]);
+     *
+     * //Raise an intent without a context by using the null context type
+     * await fdc3.raiseIntent("StartChat", {type: "fdc3.nothing"});
+     *
+     * //Raise an intent and retrieve a result from the IntentResolution
+     * let resolution = await agent.raiseIntent("intentName", context);
+     * try {
+     * 	   const result = await resolution.getResult();
+     *     if (result && result.broadcast) { //detect whether the result is Context or a Channel
+     *         console.log(`${resolution.source} returned a channel with id ${result.id}`);
+     *     } else if (result){
+     *         console.log(`${resolution.source} returned data: ${JSON.stringify(result)}`);
+     *     } else {
+     *         console.error(`${resolution.source} didn't return anything`
+     *     }
+     * } catch(error) {
+     *     console.error(`${resolution.source} returned an error: ${error}`);
+     * }
+     * ```
+     */
+    raiseIntent(intent: string, context: Context_2, app?: AppIdentifier): Promise<IntentResolution_2>;
+    /**
+     * Finds and raises an intent against apps registered with the desktop agent based on the type of the specified context data example.
+     *
+     * The desktop agent SHOULD first resolve to a specific intent based on the provided context if more than one intent is available for the specified context. This MAY be achieved by displaying a resolver UI. It SHOULD then resolve to a specific app to handle the selected intent and specified context.
+     * Alternatively, the specific app or app instance to target can also be provided, in which case the resolver SHOULD only offer intents supported by the specified application.
+     *
+     * Using `raiseIntentForContext` is similar to calling `findIntentsByContext`, and then raising an intent against one of the returned apps, except in this case the desktop agent has the opportunity to provide the user with a richer selection interface where they can choose both the intent and target app.
+     *
+     * Returns an `IntentResolution` object, see `raiseIntent()` for details.
+     *
+     * If a target intent and app cannot be found with the criteria provided or the user either closes the resolver UI or otherwise cancels resolution, the promise MUST be rejected with an `Error` object with a `message` chosen from the `ResolveError` enumeration. If a specific target `app` parameter was set, but either the app or app instance is not available, the promise MUST be rejected with an `Error` object with either the `ResolveError.TargetAppUnavailable` or `ResolveError.TargetInstanceUnavailable` string as its `message`.  If an invalid context object is passed as an argument the promise MUST be rejected with an `Error` object with the `ResolveError.MalformedContext` string as its `message`.
+     *
+     * ```javascript
+     * // Resolve against all intents registered for the type of the specified context
+     * await fdc3.raiseIntentForContext(context);
+     *
+     * // Resolve against all intents registered by a specific target app for the specified context
+     * await fdc3.raiseIntentForContext(context, targetAppIdentifier);
+     * ```
+     */
+    raiseIntentForContext(context: Context_2, app?: AppIdentifier): Promise<IntentResolution_2>;
+    /**
+     * Adds a listener for incoming intents from the Desktop Agent. The handler function may return void or a promise that resolves to an `IntentResult`, which is either a `Context` object, representing any data that should be returned to the app that raised the intent, a `Channel` Object, a `PrivateChannel` over which data responses will be sent, or `void`. The `IntentResult` will be returned to the app that raised the intent via the `IntentResolution` and retrieved from it using the `getResult()` function.
+     *
+     * The Desktop Agent MUST reject the promise returned by the `getResult()` function of `IntentResolution` if: (1) the intent handling function's returned promise rejects, (2) the intent handling function doesn't return a promise, or (3) the returned promise resolves to an invalid type.
+     *
+     * The `PrivateChannel` type is provided to support synchronization of data transmitted over returned channels, by allowing both parties to listen for events denoting subscription and unsubscription from the returned channel. `PrivateChannels` are only retrievable via raising an intent.
+     *
+     * Optional metadata about the raised intent, including the app that originated the message, SHOULD be provided by the desktop agent implementation.
+     *
+     * ```javascript
+     * //Handle a raised intent
+     * const listener = fdc3.addIntentListener('StartChat', context => {
+     *     // start chat has been requested by another application
+     *     return;
+     * });
+     *
+     * //Handle a raised intent and log the originating app metadata
+     * const listener = fdc3.addIntentListener('StartChat', (contact, metadata) => {
+     *   console.log(`Received intent StartChat\nContext: ${contact}\nOriginating app: ${metadata?.source}`);
+     *   return;
+     * });
+     *
+     * //Handle a raised intent and return Context data via a promise
+     * fdc3.addIntentListener("CreateOrder", (context) => {
+     *     return new Promise<Context>((resolve) => {
+     *         // go create the order
+     *         resolve({type: "fdc3.order", id: { "orderId": 1234}});
+     *	   });
+     * });
+     *
+     * //Handle a raised intent and return a Private Channel over which response will be sent
+     * fdc3.addIntentListener("QuoteStream", async (context) => {
+     *   const channel: PrivateChannel = await fdc3.createPrivateChannel();
+     *   const symbol = context.id.symbol;
+     *
+     *   // Called when the remote side adds a context listener
+     *   const addContextListener = channel.onAddContextListener((contextType) => {
+     *     // broadcast price quotes as they come in from our quote feed
+     *     feed.onQuote(symbol, (price) => {
+     *       channel.broadcast({ type: "price", price});
+     *     });
+     *   });
+     *
+     *   // Stop the feed if the remote side closes
+     *   const disconnectListener = channel.onDisconnect(() => {
+     *     feed.stop(symbol);
+     *   });
+     *
+     *   return channel;
+     * });
+     * ```
+     */
+    addIntentListener(intent: string, handler: IntentHandler): Promise<Listener_2>;
+    /**
+     * Adds a listener for incoming context broadcasts from the Desktop Agent via User channels. If the consumer is only interested in a context of a particular type, they can they can specify that type. If the consumer is able to receive context of any type or will inspect types received, then they can pass `null` as the `contextType` parameter to receive all context types.
+     *
+     * Context broadcasts are only received from apps that are joined to the same User channel as the listening application, hence, if the application is not currently joined to a channel no broadcasts will be received. If this function is called after the app has already joined a channel and the channel already contains context that would be passed to the context listener, then it will be called immediately with that context.
+     *
+     * Optional metadata about the context message, including the app that originated the message, SHOULD be provided by the desktop agent implementation.
+     *
+     * ```javascript
+     * // any context
+     * const listener = await fdc3.addContextListener(null, context => { ... });
+     *
+     * // listener for a specific type
+     * const contactListener = await fdc3.addContextListener('fdc3.contact', contact => { ... });
+     *
+     * // listener that logs metadata for the message a specific type
+     * const contactListener = await fdc3.addContextListener('fdc3.contact', (contact, metadata) => {
+     *   console.log(`Received context message\nContext: ${contact}\nOriginating app: ${metadata?.source}`);
+     *   //do something else with the context
+     * });
+     * ```
+     */
+    addContextListener(contextType: string | null, handler: ContextHandler_2): Promise<Listener_2>;
+    /**
+     * Retrieves a list of the User channels available for the app to join.
+     */
+    getUserChannels(): Promise<Array<Channel_2>>;
+    /**
+     * Optional function that joins the app to the specified User channel. In most cases, applications SHOULD be joined to channels via UX provided to the application by the desktop agent, rather than calling this function directly.
+     *
+     * If an app is joined to a channel, all `fdc3.broadcast` calls will go to the channel, and all listeners assigned via `fdc3.addContextListener` will listen on the channel.
+     *
+     * If the channel already contains context that would be passed to context listeners assed via `fdc3.addContextListener` then those listeners will be called immediately with that context.
+     *
+     * An app can only be joined to one channel at a time.
+     *
+     * If an error occurs (such as the channel is unavailable or the join request is denied) the promise MUST be rejected with an `Error` Object with a `message` chosen from the `ChannelError` enumeration.
+     *
+     * ```javascript
+     *   // get all system channels
+     *   const channels = await fdc3.getUserChannels();
+     *   // create UI to pick from the User channels
+     *   // join the channel on selection
+     *   fdc3.joinUserChannel(selectedChannel.id);
+     *  ```
+     */
+    joinUserChannel(channelId: string): Promise<void>;
+    /**
+     * Returns a `Channel` object for the specified channel, creating it (as an _App_ channel) if it does not exist.
+     *
+     * If the Channel cannot be created or access was denied, the returned promise MUST be rejected with an `Error` Object with a `message` chosen from the `ChannelError` enumeration.
+     *
+     * ```javascript
+     * try {
+     *   const myChannel = await fdc3.getOrCreateChannel("myChannel");
+     *   const myChannel.addContextListener(null, context => {});
+     * }
+     * catch (err){
+     *   //app could not register the channel
+     * }
+     * ```
+     */
+    getOrCreateChannel(channelId: string): Promise<Channel_2>;
+    /**
+     * 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.
+     *
+     * If the `PrivateChannel` cannot be created, the returned promise MUST be rejected with an `Error` object with a `message` chosen from the `ChannelError` enumeration.
+     *
+     * The `PrivateChannel` type is provided to support synchronisation of data transmitted over returned channels, by allowing both parties to listen for events denoting subscription and unsubscription from the returned channel. `PrivateChannels` are only retrievable via raising an intent.
+     *
+     *  * It is intended that Desktop Agent implementations:
+     * - SHOULD restrict external apps from listening or publishing on this channel.
+     * - MUST prevent `PrivateChannels` from being retrieved via fdc3.getOrCreateChannel.
+     * - MUST provide the `id` value for the channel as required by the `Channel` interface.
+     *
+     * ```javascript
+     * fdc3.addIntentListener("QuoteStream", async (context) => {
+     * 	const channel: PrivateChannel = await fdc3.createPrivateChannel();
+     * 	const symbol = context.id.ticker;
+     *
+     * 	// This gets called when the remote side adds a context listener
+     * 	const addContextListener = channel.onAddContextListener((contextType) => {
+     * 		// broadcast price quotes as they come in from our quote feed
+     * 		feed.onQuote(symbol, (price) => {
+     * 			channel.broadcast({ type: "price", price});
+     * 		});
+     * 	});
+     *
+     * 	// This gets called when the remote side calls Listener.unsubscribe()
+     * 	const unsubscriberListener = channel.onUnsubscribe((contextType) => {
+     * 		feed.stop(symbol);
+     * 	});
+     *
+     * 	// This gets called if the remote side closes
+     * 	const disconnectListener = channel.onDisconnect(() => {
+     * 		feed.stop(symbol);
+     * 	})
+     *
+     * 	return channel;
+     * });
+     * ```
+     */
+    createPrivateChannel(): Promise<PrivateChannel>;
+    /**
+     * Optional function that returns the `Channel` object for the current User channel membership. In most cases, an application's membership of channels SHOULD be managed via UX provided to the application by the desktop agent, rather than calling this function directly.
+     *
+     * Returns `null` if the app is not joined to a channel.
+     */
+    getCurrentChannel(): Promise<Channel_2 | null>;
+    /**
+     * Optional function that removes the app from any User channel membership. In most cases, an application's membership of channels SHOULD be managed via UX provided to the application by the desktop agent, rather than calling this function directly.
+     *
+     * Context broadcast and listening through the top-level `fdc3.broadcast` and `fdc3.addContextListener` will be a no-op when the app is not on a channel.
+     *
+     * ```javascript
+     * //desktop-agent scope context listener
+     * const fdc3Listener = fdc3.addContextListener(null, context => {});
+     * await fdc3.leaveCurrentChannel();
+     * //the fdc3Listener will now cease receiving context
+     * //listening on a specific channel, retrieved via fdc3.getOrCreateChannel(), will continue to work:
+     * redChannel.addContextListener(null, channelListener);
+     * ```
+     */
+    leaveCurrentChannel(): Promise<void>;
+    /**
+     * Retrieves information about the FDC3 Desktop Agent implementation, including the supported version
+     * of the FDC3 specification, the name of the provider of the implementation, its own version number
+     * and the metadata of the calling application according to the desktop agent.
+     *
+     * Returns an `ImplementationMetadata` object.  This metadata object can be used to vary the behavior
+     * of an application based on the version supported by the Desktop Agent and for logging purposes.
+     *
+     * ```js
+     * import {compareVersionNumbers, versionIsAtLeast} from '@finos/fdc3';
+     *
+     * if (fdc3.getInfo && versionIsAtLeast(await fdc3.getInfo(), "1.2")) {
+     *   await fdc3.raiseIntentForContext(context);
+     * } else {
+     *   await fdc3.raiseIntent("ViewChart", context);
+     * }
+     * ```
+     *
+     * The `ImplementationMetadata` object returned also includes the metadata for the calling application,
+     * according to the Desktop Agent. This allows the application to retrieve its own `appId`, `instanceId`
+     * and other details, e.g.:
+     *
+     * ```js
+     * let implementationMetadata = await fdc3.getInfo();
+     * let {appId, instanceId} = implementationMetadata.appMetadata;
+     * ```
+     */
+    getInfo(): Promise<ImplementationMetadata_2>;
+    /**
+     * 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.
+     *
+     * ```js
+     * let appIdentifier = { appId: "MyAppId@my.appd.com" }
+     * let appMetadata = await fdc3.getAppMetadata(appIdentifier);
+     * ```
+     */
+    getAppMetadata(app: AppIdentifier): Promise<AppMetadata_2>;
+    /**
+     * Adds a listener for incoming context broadcasts from the Desktop Agent.
+     * @deprecated use `addContextListener(null, handler)` instead of `addContextListener(handler)`. Provided for backwards compatibility with versions FDC3 standard <2.0.
+     */
+    addContextListener(handler: ContextHandler_2): Promise<Listener_2>;
+    /**
+     * @deprecated Alias to the `getUserChannels` function provided for backwards compatibility with versions FDC3 standard <2.0.
+     */
+    getSystemChannels(): Promise<Array<Channel_2>>;
+    /**
+     * @deprecated Alias to the `joinUserChannel` function Provided for backwards compatibility with versions FDC3 standard <2.0.
+     */
+    joinChannel(channelId: string): Promise<void>;
+    /**
+     * @deprecated version of `open` that launches an app by by name rather than `AppIdentifier`. Provided for backwards compatibility with versions FDC3 standard <2.0.
+     *
+     * ```javascript
+     * //Open an app without context, using the app name
+     * let instanceMetadata = await fdc3.open('myApp');
+     * ```
+     */
+    open(name: string, context?: Context_2): Promise<AppIdentifier>;
+    /**
+     * @deprecated version of `raiseIntent` that targets an app by by name rather than `AppIdentifier`. Provided for backwards compatibility with versions FDC3 standard <2.0.
+     *
+     * ```javascript
+     * // use the `name` metadata of an app to describe the target app for the intent
+     * await fdc3.raiseIntent("StartChat", context, appIntent.apps[0].name);
+     * ```
+     */
+    raiseIntent(intent: string, context: Context_2, name: string): Promise<IntentResolution_2>;
+    /**
+     * @deprecated version of `raiseIntentForContext` that targets an app by by name rather than `AppIdentifier`. Provided for backwards compatibility with versions FDC3 standard <2.0.
+     *
+     * ```javascript
+     * // Resolve against all intents registered by a specific target app name for the specified context
+     * await fdc3.raiseIntentForContext(context, targetAppName);
+     * ```
+     */
+    raiseIntentForContext(context: Context_2, name: string): Promise<IntentResolution_2>;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2019 FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * A system channel will be global enough to have a presence across many apps. This gives us some hints
+ * to render them in a standard way. It is assumed it may have other properties too, but if it has these,
+ * this is their meaning.
+ */
+declare interface DisplayMetadata {
+    /**
+     * A user-readable name for this channel, e.g: `"Red"`
+     */
+    readonly name?: string;
+    /**
+     * The color that should be associated within this channel when displaying this channel in a UI, e.g: `0xFF0000`.
+     */
+    readonly color?: string;
+    /**
+     * A URL of an image that can be used to display this channel
+     */
+    readonly glyph?: string;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * A system channel will be global enough to have a presence across many apps. This gives us some hints
+ * to render them in a standard way. It is assumed it may have other properties too, but if it has these,
+ * this is their meaning.
+ */
+declare interface DisplayMetadata_2 {
+    /**
+     * A user-readable name for this channel, e.g: `"Red"`
+     */
+    readonly name?: string;
+    /**
+     * The color that should be associated within this channel when displaying this channel in a UI, e.g: `0xFF0000`.
+     */
+    readonly color?: string;
+    /**
+     * A URL of an image that can be used to display this channel
+     */
+    readonly glyph?: string;
+}
+
+declare interface Email {
+    recipients: RecipientsObject;
+    subject?: string;
+    textBody?: string;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface FluffyID {
+    email?: string;
+    FDS_ID?: string;
+    [property: string]: any;
+}
+
+declare interface FluffyMarket {
+    BBG?: string;
+    COUNTRY_ISOALPHA2?: string;
+    MIC?: string;
+    name?: string;
+    [property: string]: any;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+declare interface Icon {
+    /** The icon url */
+    readonly src: string;
+    /** The icon dimension, formatted as `<height>x<width>`. */
+    readonly size?: string;
+    /** Icon media type. If not present the Desktop Agent may use the src file extension. */
+    readonly type?: string;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+declare interface Image_2 {
+    /** The image url. */
+    readonly src: string;
+    /** The image dimension, formatted as `<height>x<width>`. */
+    readonly size?: string;
+    /** Image media type. If not present the Desktop Agent may use the src file extension. */
+    readonly type?: string;
+    /** Caption for the image. */
+    readonly label?: string;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2021 FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * Metadata relating to the FDC3 Desktop Agent implementation and its provider.
+ */
+declare interface ImplementationMetadata {
+    /** The version number of the FDC3 specification that the implementation provides.
+     *  The string must be a numeric semver version, e.g. 1.2 or 1.2.1.
+     */
+    readonly fdc3Version: string;
+    /** The name of the provider of the FDC3 Desktop Agent Implementation (e.g. Finsemble, Glue42, OpenFin etc.). */
+    readonly provider: string;
+    /** The version of the provider of the FDC3 Desktop Agent Implementation (e.g. 5.3.0). */
+    readonly providerVersion?: string;
+}
+
+/**
+ * Metadata relating to the FDC3 Desktop Agent implementation and its provider.
+ */
+declare interface ImplementationMetadata_2 {
+    /** The version number of the FDC3 specification that the implementation provides.
+     *  The string must be a numeric semver version, e.g. 1.2 or 1.2.1.
+     */
+    readonly fdc3Version: string;
+    /** The name of the provider of the Desktop Agent implementation (e.g. Finsemble, Glue42, OpenFin etc.). */
+    readonly provider: string;
+    /** The version of the provider of the Desktop Agent implementation (e.g. 5.3.0). */
+    readonly providerVersion?: string;
+    /** Metadata indicating whether the Desktop Agent implements optional features of
+     *  the Desktop Agent API.
+     */
+    readonly optionalFeatures: {
+        /** Used to indicate whether the exposure of 'originating app metadata' for
+         *  context and intent messages is supported by the Desktop Agent.*/
+        readonly OriginatingAppMetadata: boolean;
+        /** Used to indicate whether the optional `fdc3.joinUserChannel`,
+         *  `fdc3.getCurrentChannel` and `fdc3.leaveCurrentChannel` are implemented by
+         *  the Desktop Agent.*/
+        readonly UserChannelMembershipAPIs: boolean;
+    };
+    /** The calling application instance's own metadata, according to the Desktop Agent (MUST include at least the `appId` and `instanceId`). */
+    readonly appMetadata: AppMetadata_2;
+}
+
+declare interface Instrument {
+    id: InstrumentID;
+    type: string;
+    name?: string;
+}
+
+declare interface Instrument_2 {
+    id: StickyID;
+    market?: FluffyMarket;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface InstrumentElement {
+    id: PurpleID;
+    market?: PurpleMarket;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface InstrumentID {
+    BBG?: string;
+    CUSIP?: string;
+    FDS_ID?: string;
+    FIGI?: string;
+    ISIN?: string;
+    PERMID?: string;
+    RIC?: string;
+    SEDOL?: string;
+    ticker?: string;
+}
+
+declare interface InstrumentList {
+    instruments: Instrument[];
+    type: string;
+    id?: {
+        [key: string]: string;
+    };
+    name?: string;
+}
+
+declare interface InstrumentList_2 {
+    instruments: InstrumentElement[];
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+/**
+ * Describes a callback that handles a context event and may return a
+ * promise of a Context, Channel object or void to be returned to the
+ * application that raised the intent.
+ * Used when attaching listeners for raised intents.
+ *
+ * Optional metadata about the raised intent, including the app that originated
+ * the message, SHOULD be provided by the desktop agent implementation.
+ */
+declare type IntentHandler = (context: Context_2, metadata?: ContextMetadata) => Promise<IntentResult> | void;
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2019 FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * Intent descriptor
+ */
+declare interface IntentMetadata {
+    /** The unique name of the intent that can be invoked by the raiseIntent call */
+    readonly name: string;
+    /** A friendly display name for the intent that should be used to render UI elements */
+    readonly displayName: string;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+/**
+ * Intent descriptor
+ */
+declare interface IntentMetadata_2 {
+    /** The unique name of the intent that can be invoked by the raiseIntent call */
+    readonly name: string;
+    /** Display name for the intent.
+     * @deprecated Use the intent name for display as display name may vary for
+     * each application as it is defined in the app's AppD record.
+     */
+    readonly displayName: string;
+}
+
+/**
+ * IntentResolution provides a standard format for data returned upon resolving an intent.
+ * ```javascript
+ * //resolve a "Chain" type intent
+ * var intentR = await agent.raiseIntent("intentName", context);
+ * //resolve a "Client-Service" type intent with data response
+ * var intentR = await agent.raiseIntent("intentName", context);
+ * var dataR = intentR.data;
+ * ```
+ */
+declare interface IntentResolution {
+    readonly source: TargetApp;
+    /**
+     * @deprecated not assignable from intent listeners
+     */
+    readonly data?: object;
+    readonly version: string;
+}
+
+/**
+ * IntentResolution provides a standard format for data returned upon resolving an intent.
+ *
+ * ```javascript
+ * //resolve a "Chain" type intent
+ * let resolution = await agent.raiseIntent("intentName", context);
+ *
+ * //resolve a "Client-Service" type intent with a data response or a Channel
+ * let resolution = await agent.raiseIntent("intentName", context);
+ * try {
+ * 	   const result = await resolution.getResult();
+ *     if (result && result.broadcast) {
+ *         console.log(`${resolution.source} returned a channel with id ${result.id}`);
+ *     } else if (result){
+ *         console.log(`${resolution.source} returned data: ${JSON.stringify(result)}`);
+ *     } else {
+ *         console.error(`${resolution.source} didn't return data`
+ *     }
+ * } catch(error) {
+ *     console.error(`${resolution.source} returned an error: ${error}`);
+ * }
+ *
+ * // Use metadata about the resolving app instance to target a further intent
+ * await agent.raiseIntent("intentName", context, resolution.source);
+ * ```
+ */
+declare interface IntentResolution_2 {
+    /**
+     * Identifier for the app instance that was selected (or started) to resolve the intent.
+     * `source.instanceId` MUST be set, indicating the specific app instance that
+     * received the intent.
+     */
+    readonly source: AppIdentifier;
+    /**
+     * The intent that was raised. May be used to determine which intent the user
+     * chose in response to `fdc3.raiseIntentForContext()`.
+     */
+    readonly intent: string;
+    /**
+     * The version number of the Intents schema being used.
+     */
+    readonly version?: string;
+    /**
+     * Retrieves a promise that will resolve to `Context` data returned
+     * by the application that resolves the raised intent, a `Channel`
+     * established and returned by the app resolving the intent or void.
+     *
+     * A `Channel` returned MAY be of the `PrivateChannel` type. The
+     * client can then `addContextListener()` on that channel to, for example,
+     * receive a stream of data.
+     *
+     * If an error occurs (i.e. an error is thrown by the handler function,
+     * the promise it returns is rejected, or the promise resolved to an invalid
+     * type) then the Desktop Agent MUST reject the promise returned by the
+     * `getResult()` function of the `IntentResolution` with a string from
+     * the `ResultError` enumeration.
+     */
+    getResult(): Promise<IntentResult>;
+}
+
+/**
+ * Intents can return results that are either context data objects
+ * or a reference to a Channel.
+ */
+declare type IntentResult = Context_2 | Channel_2 | void;
+
+declare enum Intents {
+    StartCall = "StartCall",
+    StartChat = "StartChat",
+    ViewChart = "ViewChart",
+    ViewContact = "ViewContact",
+    ViewQuote = "ViewQuote",
+    ViewNews = "ViewNews",
+    ViewInstrument = "ViewInstrument",
+    ViewAnalysis = "ViewAnalysis"
+}
+
+declare enum Intents_2 {
+    StartCall = "StartCall",
+    StartChat = "StartChat",
+    StartEmail = "StartEmail",
+    ViewAnalysis = "ViewAnalysis",
+    ViewChart = "ViewChart",
+    ViewContact = "ViewContact",
+    ViewHoldings = "ViewHoldings",
+    ViewInstrument = "ViewInstrument",
+    ViewInteractions = "ViewInteractions",
+    ViewNews = "ViewNews",
+    ViewOrders = "ViewOrders",
+    ViewProfile = "ViewProfile",
+    ViewQuote = "ViewQuote",
+    ViewResearch = "ViewResearch"
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2019 FINOS FDC3 contributors - see NOTICE file
+ */
+declare interface Listener {
+    /**
+     * Unsubscribe the listener object.
+     */
+    unsubscribe(): void;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+declare interface Listener_2 {
+    /**
+     * Unsubscribe the listener object.
+     */
+    unsubscribe(): void;
+}
+
+declare interface Nothing {
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright 2019 FINOS FDC3 contributors - see NOTICE file
+ */
+declare enum OpenError {
+    AppNotFound = "AppNotFound",
+    ErrorOnLaunch = "ErrorOnLaunch",
+    AppTimeout = "AppTimeout",
+    ResolverUnavailable = "ResolverUnavailable"
+}
+
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright FINOS FDC3 contributors - see NOTICE file
+ */
+/** Constants representing the errors that can be encountered when calling the `open` method on the DesktopAgent object (`fdc3`). */
+declare enum OpenError_2 {
+    /** Returned if the specified application is not found.*/
+    AppNotFound = "AppNotFound",
+    /** Returned if the specified application fails to launch correctly.*/
+    ErrorOnLaunch = "ErrorOnLaunch",
+    /** Returned if the specified application launches but fails to add a context listener in order to receive the context passed to the `fdc3.open` call.*/
+    AppTimeout = "AppTimeout",
+    /** Returned if the FDC3 desktop agent implementation is not currently able to handle the request.*/
+    ResolverUnavailable = "ResolverUnavailable",
+    /** Returned if a call to the `open` function is made with an invalid context argument. Contexts should be Objects with at least a `type` field that has a `string` value.*/
+    MalformedContext = "MalformedContext"
+}
+
+declare interface Organization {
+    id: OrganizationID;
+    type: string;
+    name?: string;
+}
+
+declare interface Organization_2 {
+    id: OrganizationID_2;
+    type: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface OrganizationID {
+    FDS_ID?: string;
+    LEI?: string;
+    PERMID?: string;
+}
+
+declare interface OrganizationID_2 {
+    FDS_ID?: string;
+    LEI?: string;
+    PERMID?: string;
+    [property: string]: any;
+}
+
+declare interface Portfolio {
+    positions: Position[];
+    type: string;
+    id?: {
+        [key: string]: string;
+    };
+    name?: string;
+}
+
+declare interface Portfolio_2 {
+    positions: PositionElement[];
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface Position {
+    holding: number;
+    instrument: Instrument;
+    type: string;
+    id?: {
+        [key: string]: string;
+    };
+    name?: string;
+}
+
+declare interface Position_2 {
+    holding: number;
+    instrument: InstrumentElement;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface PositionElement {
+    holding: number;
+    instrument: InstrumentElement;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+/**
+ * Object representing a private context channel, which is intended to support
+ * secure communication between applications, and extends the Channel interface
+ * with event handlers which provide information on the connection state of both
+ * parties, ensuring that desktop agents do not need to queue or retain messages
+ * that are broadcast before a context listener is added and that applications
+ * are able to stop broadcasting messages when the other party has disconnected.
+ *
+ * It is intended that Desktop Agent implementations:
+ * - SHOULD restrict external apps from listening or publishing on this channel.
+ * - MUST prevent private channels from being retrieved via fdc3.getOrCreateChannel.
+ * - MUST provide the `id` value for the channel as required by the Channel interface.
+ */
+declare interface PrivateChannel extends Channel_2 {
+    /**
+     * Adds a listener that will be called each time that the remote app invokes
+     * addContextListener on this channel.
+     *
+     * Desktop Agents MUST call this for each invocation of addContextListener on this
+     * channel, including those that occurred before this handler was registered
+     * (to prevent race conditions).
+     */
+    onAddContextListener(handler: (contextType?: string) => void): Listener_2;
+    /**
+     * Adds a listener that will be called whenever the remote app invokes
+     * Listener.unsubscribe() on a context listener that it previously added.
+     *
+     * Desktop Agents MUST call this when disconnect() is called by the other party, for
+     * each listener that they have added.
+     */
+    onUnsubscribe(handler: (contextType?: string) => void): Listener_2;
+    /**
+     * Adds a listener that will be called when the remote app terminates, for example
+     * when its window is closed or because disconnect was called. This is in addition
+     * to calls that will be made to onUnsubscribe listeners.
+     */
+    onDisconnect(handler: () => void): Listener_2;
+    /**
+     * May be called to indicate that a participant will no longer interact with this channel.
+     *
+     * After this function has been called, Desktop Agents SHOULD prevent apps from broadcasting
+     * on this channel and MUST automatically call Listener.unsubscribe() for each listener that
+     * they've added (causing any onUnsubscribe handler added by the other party to be called)
+     * before triggering any onDisconnect handler added by the other party.
+     */
+    disconnect(): void;
+}
+
+declare interface PurpleID {
+    BBG?: string;
+    CUSIP?: string;
+    FDS_ID?: string;
+    FIGI?: string;
+    ISIN?: string;
+    PERMID?: string;
+    RIC?: string;
+    SEDOL?: string;
+    ticker?: string;
+    [property: string]: any;
+}
+
+declare interface PurpleMarket {
+    BBG?: string;
+    COUNTRY_ISOALPHA2?: string;
+    MIC?: string;
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface RecipientsID {
+    email?: string;
+    FDS_ID?: string;
+    [property: string]: any;
+}
+
+declare interface RecipientsObject {
+    id?: RecipientsID;
+    type: string;
+    name?: string;
+    contacts?: ContactElement[];
+    [property: string]: any;
+}
+
+declare enum ResolveError {
+    NoAppsFound = "NoAppsFound",
+    ResolverUnavailable = "ResolverUnavailable",
+    ResolverTimeout = "ResolverTimeout"
+}
+
+/** Constants representing the errors that can be encountered when calling the `findIntent`, `findIntentsByContext`, `raiseIntent` or `raiseIntentForContext` methods on the DesktopAgent (`fdc3`). */
+declare enum ResolveError_2 {
+    /** SHOULD be returned if no apps are available that can resolve the intent and context combination.*/
+    NoAppsFound = "NoAppsFound",
+    /** Returned if the FDC3 desktop agent implementation is not currently able to handle the request.*/
+    ResolverUnavailable = "ResolverUnavailable",
+    /** Returned if the user cancelled the resolution request, for example by closing or cancelling a resolver UI.*/
+    UserCancelled = "UserCancelledResolution",
+    /** SHOULD be returned if a timeout cancels an intent resolution that required user interaction. Please use `ResolverUnavailable` instead for situations where a resolver UI or similar fails.*/
+    ResolverTimeout = "ResolverTimeout",
+    /** Returned if a specified target application is not available or a new instance of it cannot be opened. */
+    TargetAppUnavailable = "TargetAppUnavailable",
+    /** Returned if a specified target application instance is not available, for example because it has been closed. */
+    TargetInstanceUnavailable = "TargetInstanceUnavailable",
+    /** Returned if the intent and context could not be delivered to the selected application or instance, for example because it has not added an intent handler within a timeout.*/
+    IntentDeliveryFailed = "IntentDeliveryFailed",
+    /** Returned if a call to one of the `raiseIntent` functions is made with an invalid context argument. Contexts should be Objects with at least a `type` field that has a `string` value.*/
+    MalformedContext = "MalformedContext"
+}
+
+declare enum ResultError {
+    /** Returned if the intent handler exited without returning a valid result (a promise resolving to a Context, Channel object or void). */
+    NoResultReturned = "NoResultReturned",
+    /** Returned if the Intent handler function processing the raised intent throws an error or rejects the Promise it returned. */
+    IntentHandlerRejected = "IntentHandlerRejected"
+}
+
+declare interface StickyID {
+    BBG?: string;
+    CUSIP?: string;
+    FDS_ID?: string;
+    FIGI?: string;
+    ISIN?: string;
+    PERMID?: string;
+    RIC?: string;
+    SEDOL?: string;
+    ticker?: string;
+    [property: string]: any;
+}
+
+declare enum Style {
+    Bar = "bar",
+    Candle = "candle",
+    Custom = "custom",
+    Heatmap = "heatmap",
+    Histogram = "histogram",
+    Line = "line",
+    Mountain = "mountain",
+    Pie = "pie",
+    Scatter = "scatter",
+    StackedBar = "stacked-bar"
+}
+
+declare type TargetApp = string | AppMetadata;
+
+declare interface TentacledID {
+    email?: string;
+    FDS_ID?: string;
+    [property: string]: any;
+}
+
+declare interface TimeRange {
+    endTime?: Date;
+    startTime?: Date;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare interface TimeRangeObject {
+    endTime?: Date;
+    startTime?: Date;
+    type: string;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+declare namespace v1_2 {
+    export {
+        AppIntent,
+        AppMetadata,
+        DisplayMetadata,
+        OpenError,
+        ResolveError,
+        ChannelError,
+        ImplementationMetadata,
+        IntentMetadata,
+        Listener,
+        ContextTypes,
+        ContextType,
+        Context,
+        ContactList,
+        Contact,
+        ContactID,
+        InstrumentList,
+        Instrument,
+        InstrumentID,
+        Country,
+        CountryID,
+        Organization,
+        OrganizationID,
+        Portfolio,
+        Position,
+        Convert,
+        Intents,
+        Channel,
+        DesktopAgent,
+        IntentResolution,
+        TargetApp,
+        ContextHandler
+    }
+}
+export { v1_2 }
+
+declare namespace v2_0 {
+    export {
+        AppIdentifier,
+        AppIntent_2 as AppIntent,
+        AppMetadata_2 as AppMetadata,
+        ContextMetadata,
+        DisplayMetadata_2 as DisplayMetadata,
+        OpenError_2 as OpenError,
+        ResolveError_2 as ResolveError,
+        ResultError,
+        ChannelError_2 as ChannelError,
+        Icon,
+        Image_2 as Image,
+        ImplementationMetadata_2 as ImplementationMetadata,
+        IntentMetadata_2 as IntentMetadata,
+        Listener_2 as Listener,
+        ContextTypes_2 as ContextTypes,
+        ContextType_2 as ContextType,
+        Chart,
+        InstrumentElement,
+        PurpleID,
+        PurpleMarket,
+        TimeRangeObject,
+        Style,
+        ChatInitSettings,
+        ContactListObject,
+        ContactElement,
+        FluffyID,
+        Contact_2 as Contact,
+        TentacledID,
+        ContactList_2 as ContactList,
+        Context_2 as Context,
+        Country_2 as Country,
+        CountryID_2 as CountryID,
+        Currency,
+        CurrencyID,
+        Email,
+        RecipientsObject,
+        RecipientsID,
+        Instrument_2 as Instrument,
+        StickyID,
+        FluffyMarket,
+        InstrumentList_2 as InstrumentList,
+        Nothing,
+        Organization_2 as Organization,
+        OrganizationID_2 as OrganizationID,
+        Portfolio_2 as Portfolio,
+        PositionElement,
+        Position_2 as Position,
+        TimeRange,
+        Valuation,
+        Convert_2 as Convert,
+        Intents_2 as Intents,
+        Channel_2 as Channel,
+        DesktopAgent_2 as DesktopAgent,
+        IntentResolution_2 as IntentResolution,
+        PrivateChannel,
+        ContextHandler_2 as ContextHandler,
+        IntentResult,
+        IntentHandler
+    }
+}
+export { v2_0 }
+
+declare interface Valuation {
+    CURRENCY_ISOCODE: string;
+    expiryTime?: Date;
+    price?: number;
+    type: string;
+    valuationTime?: Date;
+    value: number;
+    id?: {
+        [key: string]: any;
+    };
+    name?: string;
+    [property: string]: any;
+}
+
+export declare type Version = (typeof versions)[keyof typeof versions];
+
+export declare const versions: {
+    readonly v1_2: "1.2";
+    readonly v2_0: "2.0";
+};
+
+export { }