@openfin/node-adapter 34.78.19 → 34.78.21

package/out/node-adapter-alpha.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="jquery" />
 /// <reference types="node" />
 
-import { AppIdentifier } from 'fdc3v2/dist/api/AppIdentifier';
-import type { AppMetadata } from 'fdc3v1/dist/api/AppMetadata';
 import { EventEmitter } from 'events';
 
 /**
@@ -138,6 +136,31 @@ declare type AppAssetRequest = {
     alias: string;
 };
 
+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>;
+}
+
 /**
  * An object representing an application. Allows the developer to create,
  * execute, show/close an application as well as listen to {@link OpenFin.ApplicationEvents application events}.
@@ -1347,6 +1370,60 @@ declare type ApplySnapshotPayload = {
     options?: ApplySnapshotOptions;
 };
 
+/**
+ * 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;
+}
+
 /**
  * @interface
  */
@@ -1743,6 +1820,48 @@ declare type BoundsChangingEvent = BoundsChangeEvent & {
     type: 'bounds-changing';
 };
 
+declare interface BrowserWindow {
+    /**
+     * True if the window has been opened and its GoldenLayout instance initialised.
+     */
+    isInitialised: boolean;
+
+    /**
+     * Creates a window configuration object from the Popout.
+     */
+    toConfig(): {
+        dimensions: {
+            width: number;
+            height: number;
+            left: number;
+            top: number;
+        };
+        content: Config;
+        parentId: string;
+        indexInParent: number;
+    };
+
+    /**
+     * Returns the GoldenLayout instance from the child window
+     */
+    getGlInstance(): GoldenLayout_2;
+
+    /**
+     * Returns the native Window object
+     */
+    getWindow(): Window;
+
+    /**
+     * Closes the popout
+     */
+    close(): void;
+
+    /**
+     * Returns the popout to its original position as specified in parentId and indexInParent
+     */
+    popIn(): void;
+}
+
 /**
  * Configuration for page capture.
  *
@@ -2008,7 +2127,25 @@ declare class Channel extends EmitterBase<ChannelEvent> {
 
 declare type Channel_2 = OpenFin.Fin['InterApplicationBus']['Channel'];
 
-declare type Channel_3 = OpenFin.Fin['InterApplicationBus']['Channel'];
+declare interface Channel_3 {
+    id: string;
+    type: string;
+    displayMetadata?: DisplayMetadata;
+    broadcast(context: Context): void;
+    getCurrentContext(contextType?: string): Promise<Context | null>;
+    addContextListener(contextType: string | null, handler: ContextHandler): Listener & Promise<Listener>;
+}
+
+declare interface Channel_4 {
+    readonly id: string;
+    readonly type: 'user' | 'app' | 'private';
+    readonly displayMetadata?: DisplayMetadata_2;
+    broadcast(context: Context_2): Promise<void>;
+    getCurrentContext(contextType?: string): Promise<Context_2 | null>;
+    addContextListener(contextType: string | null, handler: ContextHandler_2): Listener_2 & Promise<Listener_2>;
+}
+
+declare type Channel_5 = OpenFin.Fin['InterApplicationBus']['Channel'];
 
 declare type ChannelAction = OpenFin.ChannelAction;
 
@@ -3063,6 +3200,31 @@ declare class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible
     close(): Promise<void>;
 }
 
+declare interface ComponentConfig extends ItemConfig {
+    /**
+     * The name of the component as specified in layout.registerComponent. Mandatory if type is 'component'.
+     */
+    componentName: string;
+
+    /**
+     * A serialisable object. Will be passed to the component constructor function and will be the value returned by
+     * container.getState().
+     */
+    componentState?: any;
+}
+
+declare interface Config {
+    settings?: Settings;
+    dimensions?: Dimensions;
+    labels?: Labels;
+    content?: ItemConfigType[];
+    /**
+     * (Only on layout config object)
+     * Id of the currently maximised content item
+     */
+    maximisedItemId?: string;
+}
+
 declare type ConfigWithRuntime = BaseConfig & {
     runtime: RuntimeConfig;
 };
@@ -3357,6 +3519,103 @@ declare type ConstWindowOptions = {
     viewVisibility?: ViewVisibilityOptions;
 };
 
+declare interface Container extends EventEmitter_2 {
+    /**
+     * The current width of the container in pixel
+     */
+    width: number;
+
+    /**
+     * The current height of the container in pixel
+     */
+    height: number;
+
+    /**
+     * A reference to the component-item that controls this container
+     */
+    parent: ContentItem;
+
+    /**
+     * A reference to the tab that controls this container. Will initially be null
+     * (and populated once a tab event has been fired).
+     */
+    tab: Tab;
+
+    /**
+     * The current title of the container
+     */
+    title: string;
+
+    /*
+    * A reference to the GoldenLayout instance this container belongs to
+    */
+    layoutManager: GoldenLayout_2;
+
+    /**
+     * True if the item is currently hidden
+     */
+    isHidden: boolean;
+
+    /**
+     * Overwrites the components state with the provided value. To only change parts of the componentState see
+     * extendState below. This is the main mechanism for saving the state of a component. This state will be the
+     * value of componentState when layout.toConfig() is called and will be passed back to the component's
+     * constructor function. It will also be used when the component is opened in a new window.
+     * @param state A serialisable object
+     */
+    setState(state: any): void;
+
+    /**
+     * The same as setState but does not emit 'stateChanged' event
+     * @param {serialisable} state
+     */
+    setStateSkipEvent(state: any): void;
+
+    /**
+     * This is similar to setState, but merges the provided state into the current one, rather than overwriting it.
+     * @param state A serialisable object
+     */
+    extendState(state: any): void;
+
+    /**
+     * Returns the current state.
+     */
+    getState(): any;
+
+    /**
+     * Returns the container's inner element as a jQuery element
+     */
+    getElement(): JQuery;
+
+    /**
+     * hides the container or returns false if hiding it is not possible
+     */
+    hide(): boolean;
+
+    /**
+     * shows the container or returns false if showing it is not possible
+     */
+    show(): boolean;
+
+    /**
+     * Sets the container to the specified size or returns false if that's not possible
+     * @param width the new width in pixel
+     * @param height the new height in pixel
+     */
+    setSize(width: number, height: number): boolean;
+
+    /**
+     * Sets the item's title to the provided value. Triggers titleChanged and stateChanged events
+     * @param title the new title
+     */
+    setTitle(title: string): void;
+
+    /**
+     * Closes the container or returns false if that is not possible
+     */
+    close(): boolean;
+}
+
 declare type ContentCreationBehaviorNames = 'window' | 'view' | 'block' | 'browser';
 
 /**
@@ -3427,6 +3686,218 @@ declare type ContentCreationRulesEvent = NamedEvent & {
     disposition: string;
 };
 
+declare interface ContentItem extends EventEmitter_2 {
+    instance: any;
+    header: any;
+    _splitter: any;
+    /**
+     * This items configuration in its current state
+     */
+    config: ItemConfigType;
+
+    /**
+     * The type of the item. Can be row, column, stack, component or root
+     */
+    type: ItemType;
+
+    /**
+     * An array of items that are children of this item
+     */
+    contentItems: ContentItem[];
+
+    container: Container;
+    /**
+     * The item that is this item's parent (or null if the item is root)
+     */
+    parent: ContentItem;
+
+    /**
+     * A String or array of identifiers if provided in the configuration
+     */
+    id: string;
+
+    /**
+     * True if the item had been initialised
+     */
+    isInitialised: boolean;
+
+    /**
+     * True if the item is maximised
+     */
+    isMaximised: boolean;
+
+    /**
+     * True if the item is the layout's root item
+     */
+    isRoot: boolean;
+
+    /**
+     * True if the item is a row
+     */
+    isRow: boolean;
+
+    /**
+     * True if the item is a column
+     */
+    isColumn: boolean;
+
+    /**
+     * True if the item is a stack
+     */
+    isStack: boolean;
+
+    /**
+     * True if the item is a component
+     */
+    isComponent: boolean;
+
+    /**
+     * A reference to the layoutManager that controls this item
+     */
+    layoutManager: any;
+
+    /**
+     * The item's outer element
+     */
+    element: JQuery;
+
+    /**
+     * The item's inner element. Can be the same as the outer element.
+     */
+    childElementContainer: Container;
+
+    /**
+     * Adds an item as a child to this item. If the item is already a part of a layout it will be removed
+     * from its original position before adding it to this item.
+     * @param itemOrItemConfig A content item (or tree of content items) or an ItemConfiguration to create the item from
+     * @param index last index  An optional index that determines at which position the new item should be added. Default: last index.
+     */
+    addChild(itemOrItemConfig: ContentItem | ItemConfigType, index?: number): void;
+
+    /**
+     * Destroys the item and all it's children
+     * @param contentItem The contentItem that should be removed
+     * @param keepChild If true the item won't be destroyed. (Use cautiosly, if the item isn't destroyed it's up to you to destroy it later). Default: false.
+     */
+    removeChild(contentItem: ContentItem, keepChild?: boolean): void;
+
+    /**
+     * The contentItem that should be removed
+     * @param oldChild    ContentItem The contentItem that should be removed
+     * @param newChild A content item (or tree of content items) or an ItemConfiguration to create the item from
+     */
+    replaceChild(oldChild: ContentItem, newChild: ContentItem | ItemConfigType): void;
+
+    /**
+     * Updates the items size. To actually assign a new size from within a component, use container.setSize( width, height )
+     */
+    setSize(): void;
+
+    /**
+     * Sets the item's title to the provided value. Triggers titleChanged and stateChanged events
+     * @param title the new title
+     */
+    setTitle(title: string): void;
+
+    /**
+     * A powerful, yet admittedly confusing method to recursively call methods on items in a tree. Usually you wouldn't need
+     * to use it directly, but it's used internally to setSizes, destroy parts of the item tree etc.
+     * @param functionName The name of the method to invoke
+     * @param functionArguments An array of arguments to pass to every function
+     * @param bottomUp If true, the method is invoked on the lowest parts of the tree first and then bubbles upwards. Default: false
+     * @param skipSelf If true, the method will only be invoked on the item's children, but not on the item itself. Default: false
+     */
+    callDownwards(functionName: string, functionArguments?: any[], bottomUp?: boolean, skipSelf?: boolean): void;
+
+    /**
+     * Emits an event that bubbles up the item tree until it reaches the root element (and after a delay the layout manager). Useful e.g. for indicating state changes.
+     */
+    emitBubblingEvent(name: string): void;
+
+    /**
+     * Convenience method for item.parent.removeChild( item )
+     */
+    remove(): void;
+
+    /**
+     * Removes the item from its current position in the layout and opens it in a window
+     */
+    popout(): BrowserWindow;
+
+    /**
+     * Maximises the item or minimises it if it's already maximised
+     */
+    toggleMaximise(): void;
+
+    /**
+     * Selects the item. Only relevant if settings.selectionEnabled is set to true
+     */
+    select(): void;
+
+    /**
+     * Unselects the item. Only relevant if settings.selectionEnabled is set to true
+     */
+    deselect(): void;
+
+    /**
+     * Returns true if the item has the specified id or false if not
+     * @param id An id to check for
+     */
+    hasId(id: string): boolean;
+
+    /**
+     * Only Stacks have this method! It's the programmatical equivalent of clicking a tab.
+     * @param contentItem The new active content item
+     * @param preventFocus [OpenFin Custom] Indicates to openfin that the view should not be focused when activated.
+     */
+    // (CORE-198)[../docs/golden-layout-changelog.md#CORE-198 stack.setActiveView]
+    setActiveContentItem(contentItem: ContentItem, preventFocus?: boolean): void;
+
+    /**
+     * Only Stacks have this method! Returns the currently selected contentItem.
+     */
+    getActiveContentItem(): ContentItem;
+
+    /**
+     * Adds an id to an item or does nothing if the id is already present
+     * @param id The id to be added
+     */
+    addId(id: string): void;
+
+    /**
+     * Removes an id from an item or throws an error if the id couldn't be found
+     * @param id The id to be removed
+     */
+    removeId(id: string): void;
+
+    /**
+     * Calls filterFunction recursively for every item in the tree. If the function returns true the item is added to the resulting array
+     * @param filterFunction A function that determines whether an item matches certain criteria
+     */
+    getItemsByFilter(filterFunction: (contentItem: ContentItem) => boolean): ContentItem[];
+
+    /**
+     * Returns all items with the specified id.
+     * @param id An id specified in the itemConfig
+     */
+    getItemsById(id: string | string[]): ContentItem[];
+
+    /**
+     * Returns all items with the specified type
+     * @param type 'row', 'column', 'stack', 'component' or 'root'
+     */
+    getItemsByType(type: string): ContentItem[];
+
+    /**
+     * Returns all instances of the component with the specified componentName
+     * @param componentName a componentName as specified in the itemConfig
+     */
+    getComponentsByName(componentName: string): any;
+
+    _contentAreaDimensions: any;
+    _$getArea: () => any;
+}
+
 /**
  * Restrict navigation to URLs that match an allowed pattern.
  * In the lack of an allowlist, navigation to URLs that match a denied pattern would be prohibited.
@@ -3445,12 +3916,26 @@ declare type ContentNavigation = NavigationRules;
  */
 declare type ContentRedirect = NavigationRules;
 
+declare interface Context {
+    id?: { [key: string]: string };
+    name?: string;
+    type: string;
+}
+
+declare interface Context_2 {
+    id?: { [key: string]: string };
+    name?: string;
+    type: string;
+    contextMetadata?: ContextMetadata;
+    metadata?: any;
+}
+
 /**
  * Data passed between entities and applications.
  *
  * @interface
  */
-declare type Context = {
+declare type Context_3 = {
     /**
      * An object containing string key-value pairs for the bulk of the data for the context. Differs between context types.
      */
@@ -3470,7 +3955,7 @@ declare type Context = {
 /**
  * @interface
  */
-declare type ContextForIntent<MetadataType = any> = Context & {
+declare type ContextForIntent<MetadataType = any> = Context_3 & {
     metadata?: MetadataType;
 };
 
@@ -3486,19 +3971,23 @@ declare type ContextGroupInfo = {
     /**
      * Metadata for the Context Group. Contains the group's human-readable name, color, and an image, as defined by the Interop Broker.
      */
-    displayMetadata?: DisplayMetadata;
+    displayMetadata?: DisplayMetadata_3;
 };
 
 declare type ContextGroupStates = {
     [key: string]: {
-        [key: string]: Context;
+        [key: string]: Context_3;
     };
 };
 
+declare type ContextHandler = (context: Context) => void;
+
+declare type ContextHandler_2 = (context: Context_2, metadata?: ContextMetadata) => void;
+
 /**
  * Subscription function for addContextHandler.
  */
-declare type ContextHandler = (context: Context) => void;
+declare type ContextHandler_3 = (context: Context_3) => void;
 
 /**
  * Configure the context menu when right-clicking on a window.
@@ -3537,6 +4026,20 @@ declare type ContextMenuSettings = {
     reload?: boolean;
 };
 
+/**
+ * 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;
+}
+
 /**
  * @interface
  */
@@ -3699,6 +4202,45 @@ declare type DefaultDomainSettingsRule = {
     };
 };
 
+declare interface DesktopAgent {
+    open(app: TargetApp, context?: Context): Promise<void>;
+    findIntent(intent: string, context?: Context): Promise<AppIntent>;
+    findIntentsByContext(context: Context): Promise<Array<AppIntent>>;
+    broadcast(context: Context): void;
+    raiseIntent(intent: string, context: Context, app?: TargetApp): Promise<IntentResolution>;
+    raiseIntentForContext(context: Context, app?: TargetApp): Promise<IntentResolution>;
+    addIntentListener(intent: string, handler: ContextHandler): Listener;
+    joinChannel(channelId: string): Promise<void>;
+    leaveCurrentChannel(): Promise<void>;
+    getInfo(): ImplementationMetadata;
+    addContextListener(contextType: string | null, handler: ContextHandler): Listener & Promise<Listener>;
+    getOrCreateChannel(channelId: string): Promise<Channel_3>;
+    getSystemChannels(): Promise<SystemChannel[]>;
+    getCurrentChannel(): Promise<Channel_3 | null>;
+}
+
+declare interface DesktopAgent_2 {
+    open(app: AppIdentifier | TargetApp, context?: Context_2): Promise<AppIdentifier>;
+    findIntent(intent: string, context?: Context_2, resultType?: string): Promise<AppIntent_2>;
+    findIntentsByContext(context: Context_2, resultType?: string): Promise<Array<AppIntent_2>>;
+    findInstances(app: AppIdentifier): Promise<Array<AppIdentifier>>;
+    broadcast(context: Context_2): Promise<void>;
+    raiseIntent(intent: string, context: Context_2, app?: AppIdentifier | TargetApp): Promise<IntentResolution_2>;
+    raiseIntentForContext(context: Context_2, app?: AppIdentifier | TargetApp): Promise<IntentResolution_2>;
+    addIntentListener(intent: string, handler: IntentHandler): Promise<Listener_2>;
+    addContextListener(contextType: string | null, handler: ContextHandler_2): Promise<Listener_2>;
+    getUserChannels(): Promise<Array<SystemChannel>>;
+    joinUserChannel(channelId: string): Promise<void>;
+    getOrCreateChannel(channelId: string): Promise<Channel_4>;
+    createPrivateChannel(): Promise<PrivateChannel>;
+    getCurrentChannel(): Promise<Channel_3 | null>;
+    leaveCurrentChannel(): Promise<void>;
+    getInfo(): Promise<ImplementationMetadata_2>;
+    getAppMetadata(app: AppIdentifier): Promise<AppMetadata_2>;
+    getSystemChannels(): Promise<Array<SystemChannel>>;
+    joinChannel(channelId: string): Promise<void>;
+}
+
 /**
  * Generated when the desktop icon is clicked while it's already running.
  * @interface
@@ -3739,6 +4281,46 @@ declare type DidFinishLoadEvent = NamedEvent & {
     type: 'did-finish-load';
 };
 
+declare interface Dimensions {
+    /**
+     * The width of the borders between the layout items in pixel. Please note: The actual draggable area is wider
+     * than the visible one, making it safe to set this to small values without affecting usability.
+     * Default: 5
+     */
+    borderWidth?: number;
+
+    /**
+     * The minimum height an item can be resized to (in pixel).
+     * Default: 10
+     */
+    minItemHeight?: number;
+
+    /**
+     * The minimum width an item can be resized to (in pixel).
+     * Default: 10
+     */
+    minItemWidth?: number;
+
+    /**
+     * The height of the header elements in pixel. This can be changed, but your theme's header css needs to be
+     * adjusted accordingly.
+     * Default: 20
+     */
+    headerHeight?: number;
+
+    /**
+     * The width of the element that appears when an item is dragged (in pixel).
+     * Default: 300
+     */
+    dragProxyWidth?: number;
+
+    /**
+     * The height of the element that appears when an item is dragged (in pixel).
+     * Default: 200
+     */
+    dragProxyHeight?: number;
+}
+
 /**
  * @interface
  */
@@ -3771,12 +4353,52 @@ declare type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changing';
 };
 
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
 /**
  * The display data for a context group.
  *
  * @interface
  */
-declare type DisplayMetadata = {
+declare type DisplayMetadata_3 = {
     /**
      * A user-readable name for this context group, e.g: `"Red"`
      */
@@ -3847,6 +4469,8 @@ declare type Dpi = {
     vertical?: number;
 };
 
+declare interface DragSource {}
+
 /**
  * Generated when a window has been embedded.
  * @interface
@@ -4069,6 +4693,43 @@ declare class EventAggregator extends EmitterMap {
     dispatchEvent: (message: Message<any>) => boolean;
 }
 
+declare interface EventEmitter_2 {
+    [x: string]: any;
+    /**
+     * Subscribe to an event
+     * @param eventName The name of the event to describe to
+     * @param callback The function that should be invoked when the event occurs
+     * @param context The value of the this pointer in the callback function
+     */
+    on(eventName: string, callback: Function, context?: any): void;
+
+    /**
+     * Notify listeners of an event and pass arguments along
+     * @param eventName The name of the event to emit
+     */
+    emit(eventName: string, arg1?: any, arg2?: any, ...argN: any[]): void;
+
+    /**
+     * Alias for emit
+     */
+    trigger(eventName: string, arg1?: any, arg2?: any, ...argN: any[]): void;
+
+    /**
+     * Unsubscribes either all listeners if just an eventName is provided, just a specific callback if invoked with
+     * eventName and callback or just a specific callback with a specific context if invoked with all three
+     * arguments.
+     * @param eventName The name of the event to unsubscribe from
+     * @param callback The function that should be invoked when the event occurs
+     * @param context The value of the this pointer in the callback function
+     */
+    unbind(eventName: string, callback?: Function, context?: any): void;
+
+    /**
+     * Alias for unbind
+     */
+    off(eventName: string, callback?: Function, context?: any): void;
+}
+
 /**
  * Handler for an event on an EventEmitter.
  * @remarks Selects the correct type for the event
@@ -4372,6 +5033,13 @@ declare type FaviconUpdatedEvent = NamedEvent & {
     favicons: string[];
 };
 
+declare namespace FDC3 {
+    export {
+        v1,
+        v2
+    }
+}
+
 /**
  * @interface
  */
@@ -4564,8 +5232,8 @@ declare type FindInPageResult = {
 /**
  * @interface
  */
-declare type FindIntentsByContextOptions<MetadataType = IntentMetadata> = {
-    context: Context;
+declare type FindIntentsByContextOptions<MetadataType = IntentMetadata_3> = {
+    context: Context_3;
     metadata?: MetadataType;
 };
 
@@ -4969,27 +5637,265 @@ declare class GlobalHotkey extends EmitterBase<OpenFin.GlobalHotkeyEvent> {
      * });
      * ```
      */
-    isRegistered(hotkey: string): Promise<boolean>;
-}
+    isRegistered(hotkey: string): Promise<boolean>;
+}
+
+/**
+ *  [Union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types) containing every possible event that can be emitted by {@link GlobalHotkey}.  Events are
+ *  discriminated by {@link GlobalHotkeyEvent.type | their type}.  Event payloads unique to `GlobalHotkey` can be found
+ *  under the {@link OpenFin.GlobalHotkeyEvents} namespace.
+ */
+declare type GlobalHotkeyEvent = {
+    topic: 'global-hotkey';
+    hotkey: 'string';
+} & (RegisteredEvent | UnregisteredEvent);
+
+declare type GlobalHotkeyEvent_2 = Events.GlobalHotkeyEvents.GlobalHotkeyEvent;
+
+declare namespace GlobalHotkeyEvents {
+    export {
+        RegisteredEvent,
+        UnregisteredEvent,
+        GlobalHotkeyEvent
+    }
+}
+
+declare namespace GoldenLayout {
+    export {
+        GoldenLayout_2 as GoldenLayout,
+        ItemConfigType,
+        Settings,
+        Dimensions,
+        Labels,
+        ItemType,
+        ItemConfig,
+        ComponentConfig,
+        ReactComponentConfig,
+        Config,
+        ContentItem,
+        Container,
+        DragSource,
+        BrowserWindow,
+        Header,
+        Tab,
+        EventEmitter_2 as EventEmitter
+    }
+}
+
+declare class GoldenLayout_2 implements EventEmitter_2 {
+    /**
+     * The topmost item in the layout item tree. In browser terms: Think of the GoldenLayout instance as window
+     * object and of goldenLayout.root as the document.
+     */
+    root: ContentItem;
+
+    /**
+     * A reference to the (jQuery) DOM element containing the layout
+     */
+    container: JQuery;
+
+    /**
+     * True once the layout item tree has been created and the initialised event has been fired
+     */
+    isInitialised: boolean;
+
+    /**
+     * A reference to the current, extended top level config.
+     *
+     * Don't rely on this object for state saving / serialisation. Use layout.toConfig() instead.
+     */
+    config: Config;
+
+    /**
+     * The currently selected item or null if no item is selected. Only relevant if settings.selectionEnabled is set
+     * to true.
+     */
+    selectedItem: ContentItem;
+
+    /**
+     * The current outer width of the layout in pixels.
+     */
+    width: number;
+
+    /**
+     * The current outer height of the layout in pixels.
+     */
+    height: number;
+
+    /**
+     * An array of BrowserWindow instances
+     */
+    openPopouts: BrowserWindow[];
+
+    /**
+     * True if the layout has been opened as a popout by another layout.
+     */
+    isSubWindow: boolean;
+
+    /**
+     * A singleton instance of EventEmitter that works across windows
+     */
+    eventHub: EventEmitter_2;
+
+    _dragProxy: any;
+
+    dropTargetIndicator: any;
+
+    /**
+     * @param config A GoldenLayout configuration object
+     * @param container The DOM element the layout will be initialised in. Default: document.body
+     */
+    constructor(configuration: Config, container?: Element | HTMLElement | JQuery);
+
+    /*
+    * @param name 	The name of the component, as referred to by componentName in the component configuration.
+    * @param component 	A constructor or factory function. Will be invoked with new and two arguments, a
+    *                      containerobject and a component state
+    */
+    registerComponent(name: String, component: any): void;
+
+    /**
+     * Renders the layout into the container. If init() is called before the document is ready it attaches itself as
+     * a listener to the document and executes once it becomes ready.
+     */
+    init(): void;
+
+    /**
+     * Returns the current state of the layout and its components as a serialisable object.
+     */
+    toConfig(): Config;
+
+    /**
+     * Returns a component that was previously registered with layout.registerComponent().
+     * @param name The name of a previously registered component
+     */
+    getComponent(name: string): any;
+
+    /**
+     * Resizes the layout. If no arguments are provided GoldenLayout measures its container and resizes accordingly.
+     * @param width The outer width the layout should be resized to. Default: The container elements width
+     * @param height The outer height the layout should be resized to. Default: The container elements height
+     */
+    updateSize(width?: number, height?: number): void;
+
+    /**
+     * Destroys the layout. Recursively calls destroy on all components and content items, removes all event
+     * listeners and finally removes itself from the DOM.
+     */
+    destroy(): void;
+
+    /**
+     * Creates a new content item or tree of content items from configuration. Usually you wouldn't call this
+     * directly, but instead use methods like layout.createDragSource(), item.addChild() or item.replaceChild() that
+     * all call this method implicitly.
+     * @param itemConfiguration An item configuration (can be an entire tree of items)
+     * @param parent A parent item
+     */
+    createContentItem(
+    itemConfiguration?: ItemConfigType,
+    parent?: ContentItem
+    ): ContentItem;
+
+    /**
+     * Creates a new popout window with configOrContentItem as contents at the position specified in dimensions
+     * @param configOrContentItem   The content item or config that will be created in the new window. If a item is
+     *                              provided its config will be read, if config is provided, only the content key
+     *                              will be used
+     * @param dimensions    A map containing the keys left, top, width and height. Left and top can be negative to
+     *                      place the window in another screen.
+     * @param parentId  The id of the item within the current layout the child window's content will be appended to
+     *                  when popIn is clicked
+     * @param indexInParent The index at which the child window's contents will be appended to. Default: null
+     */
+    createPopout(
+    configOrContentItem: ItemConfigType | ContentItem,
+    dimensions: {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    },
+    parentId?: string,
+    indexInParent?: number
+    ): void;
+
+    /**
+     * Turns a DOM element into a dragSource, meaning that the user can drag the element directly onto the layout
+     * where it turns into a contentItem.
+     * @param element The DOM element that will be turned into a dragSource
+     * @param itemConfiguration An item configuration (can be an entire tree of items)
+     * @return the dragSource that was created. This can be used to remove the
+     *         dragSource from the layout later.
+     */
+    createDragSource(
+    element: HTMLElement | JQuery,
+    itemConfiguration: ItemConfigType
+    ): DragSource;
+
+    /**
+     * Removes a dragSource from the layout.
+     *
+     * @param dragSource The dragSource to remove
+     */
+    removeDragSource(dragSource: DragSource): void;
+
+    /**
+     * If settings.selectionEnabled is set to true, this allows to select items programmatically.
+     * @param contentItem A ContentItem instance
+     */
+    selectItem(contentItem: ContentItem): void;
+
+    /**
+     * Static method on the GoldenLayout constructor! This method will iterate through a GoldenLayout config object
+     * and replace frequent keys and values with single letter substitutes.
+     * @param config A GoldenLayout configuration object
+     */
+    static minifyConfig(config: any): any;
+
+    /**
+     * Static method on the GoldenLayout constructor! This method will reverse the minifications of minifyConfig.
+     * @param minifiedConfig A minified GoldenLayout configuration object
+     */
+    static unminifyConfig(minifiedConfig: any): any;
+
+    /**
+     * Subscribe to an event
+     * @param eventName The name of the event to describe to
+     * @param callback The function that should be invoked when the event occurs
+     * @param context The value of the this pointer in the callback function
+     */
+    on(eventName: string, callback: Function, context?: any): void;
 
-/**
- *  [Union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types) containing every possible event that can be emitted by {@link GlobalHotkey}.  Events are
- *  discriminated by {@link GlobalHotkeyEvent.type | their type}.  Event payloads unique to `GlobalHotkey` can be found
- *  under the {@link OpenFin.GlobalHotkeyEvents} namespace.
- */
-declare type GlobalHotkeyEvent = {
-    topic: 'global-hotkey';
-    hotkey: 'string';
-} & (RegisteredEvent | UnregisteredEvent);
+    /**
+     * Notify listeners of an event and pass arguments along
+     * @param eventName The name of the event to emit
+     */
+    emit(eventName: string, arg1?: any, arg2?: any, ...argN: any[]): void;
 
-declare type GlobalHotkeyEvent_2 = Events.GlobalHotkeyEvents.GlobalHotkeyEvent;
+    /**
+     * Alias for emit
+     */
+    trigger(eventName: string, arg1?: any, arg2?: any, ...argN: any[]): void;
 
-declare namespace GlobalHotkeyEvents {
-    export {
-        RegisteredEvent,
-        UnregisteredEvent,
-        GlobalHotkeyEvent
-    }
+    /**
+     * Unsubscribes either all listeners if just an eventName is provided, just a specific callback if invoked with
+     * eventName and callback or just a specific callback with a specific context if invoked with all three
+     * arguments.
+     * @param eventName The name of the event to unsubscribe from
+     * @param callback The function that should be invoked when the event occurs
+     * @param context The value of the this pointer in the callback function
+     */
+    unbind(eventName: string, callback?: Function, context?: any): void;
+
+    /**
+     * Alias for unbind
+     */
+    off(eventName: string, callback?: Function, context?: any): void;
+
+    /**
+     * Internal method that create drop areas on the far edges of window, e.g. far-right of window
+     */
+    _$createRootItemAreas(): void;
 }
 
 /**
@@ -4999,6 +5905,62 @@ declare type GpuInfo = {
     name: string;
 };
 
+declare interface Header {
+    /**
+     * A reference to the LayoutManager instance
+     */
+    layoutManager: GoldenLayout_2;
+
+    /**
+     * A reference to the Stack this Header belongs to
+     */
+    parent: ContentItem;
+
+    /**
+     * An array of the Tabs within this header
+     */
+    tabs: Tab[];
+
+    /**
+     * The currently selected activeContentItem
+     */
+    activeContentItem: ContentItem;
+
+    /**
+     * The outer (jQuery) DOM element of this Header
+     */
+    element: JQuery;
+
+    /**
+     * The (jQuery) DOM element containing the tabs
+     */
+    tabsContainer: JQuery;
+
+    /**
+     * The (jQuery) DOM element containing the close, maximise and popout button
+     */
+    controlsContainer: JQuery;
+
+    /**
+     * Hides the currently selected contentItem, shows the specified one and highlights its tab.
+     * @param contentItem The content item that will be selected
+     */
+    setActiveContentItem(contentItem: ContentItem): void;
+
+    /**
+     * Creates a new tab and associates it with a content item
+     * @param contentItem The content item the tab will be associated with
+     * @param index A zero based index, specifying the position of the new tab
+     */
+    createTab(contentItem: ContentItem, index?: number): void;
+
+    /**
+     * Finds a tab by its contentItem and removes it
+     * @param contentItem The content item the tab is associated with
+     */
+    removeTab(contentItem: ContentItem): void;
+}
+
 /**
  * Generated when a View is hidden.
  * @interface
@@ -5084,6 +6046,15 @@ declare type HotkeyEvent = BaseViewEvent & {
     type: 'hotkey';
 };
 
+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;
+}
+
 declare type Identity = OpenFin.Identity;
 
 declare type Identity_2 = OpenFin.Identity;
@@ -5136,6 +6107,17 @@ declare type IdleEvent = {
     isIdle: boolean;
 };
 
+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;
+}
+
 declare type ImageFormatOptions = {
     format: 'dataURL' | 'png' | 'bmp';
 } | {
@@ -5146,15 +6128,57 @@ declare type ImageFormatOptions = {
     quality?: number;
 };
 
+/**
+ * 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;
+}
+
 /**
  * @interface
  */
-declare type InfoForIntentOptions<MetadataType = IntentMetadata> = {
+declare type InfoForIntentOptions<MetadataType = IntentMetadata_3> = {
     /**
      * Name of the intent to get info for.
      */
     name: string;
-    context?: Context;
+    context?: Context_3;
     metadata?: MetadataType;
 };
 
@@ -5227,10 +6251,16 @@ declare type InstalledApps_2 = {
     [key: string]: InstallationInfo;
 };
 
+declare interface Intent {
+    name: string;
+    context: Context_2;
+    metadata: IntentMetadata_2;
+}
+
 /**
  * Combination of an action and a context that is passed to an application for resolution.
  */
-declare type Intent<MetadataType = IntentMetadata> = {
+declare type Intent_2<MetadataType = IntentMetadata_3> = {
     /**
      * Name of the intent.
      */
@@ -5238,25 +6268,54 @@ declare type Intent<MetadataType = IntentMetadata> = {
     /**
      * Data associated with the intent.
      */
-    context: Context;
+    context: Context_3;
     metadata?: MetadataType;
 };
 
+declare type IntentHandler = (context: Context_2, metadata?: ContextMetadata) => Promise<IntentResult> | void;
+
 /**
  * Subscription function for registerIntentHandler.
  */
-declare type IntentHandler = (intent: Intent) => void;
+declare type IntentHandler_2 = (intent: Intent_2) => void;
 
 /**
- * The type used to describe an intent within the platform.
- * @interface
+ * Intent descriptor
  */
-declare type IntentMetadata<TargetType = any> = {
+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;
+}
+
+declare type IntentMetadata_2<TargetType = any> = {
     target?: TargetType;
     resultType?: string;
     intentResolutionResultId?: string;
 };
 
+/**
+ * The type used to describe an intent within the platform.
+ * @interface
+ */
+declare type IntentMetadata_3<TargetType = any> = FDC3.v2.IntentMetadata<TargetType>;
+
+declare interface IntentResolution {
+    source: TargetApp;
+    data?: object;
+    version: string;
+}
+
+declare interface IntentResolution_2 {
+    source: AppIdentifier;
+    intent: string;
+    version?: string;
+    getResult(): Promise<IntentResult>;
+}
+
+declare type IntentResult = Context_2 | Channel_4 | PrivateChannel;
+
 /**
  * A messaging bus that allows for pub/sub messaging between different applications.
  *
@@ -5846,23 +6905,23 @@ declare class InteropBroker extends Base {
      * @param clientIdentity Identity of the Client making the request.
      */
     fdc3HandleOpen({ app, context }: {
-        app: TargetApp | AppIdentifier;
+        app: FDC3.v1.TargetApp | FDC3.v2.AppIdentifier;
         context: OpenFin.Context;
-    }, clientIdentity: OpenFin.ClientIdentity): Promise<void | AppIdentifier>;
+    }, clientIdentity: OpenFin.ClientIdentity): Promise<void | FDC3.v2.AppIdentifier>;
     /**
      * Responsible for resolving the fdc3.findInstances call.
      * Must be overridden
      * @param app AppIdentifier that was passed to fdc3.findInstances
      * @param clientIdentity Identity of the Client making the request.
      */
-    fdc3HandleFindInstances(app: AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleFindInstances(app: FDC3.v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * Responsible for resolving the fdc3.getAppMetadata call.
      * Must be overridden
      * @param app AppIdentifier that was passed to fdc3.getAppMetadata
      * @param clientIdentity Identity of the Client making the request.
      */
-    fdc3HandleGetAppMetadata(app: AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
+    fdc3HandleGetAppMetadata(app: FDC3.v2.AppIdentifier, clientIdentity: OpenFin.ClientIdentity): Promise<unknown>;
     /**
      * This function is called by the Interop Broker whenever a Context handler would fire.
      * For FDC3 2.0 you would need to override this function and add the contextMetadata as
@@ -6629,6 +7688,50 @@ declare class InteropModule extends Base {
     connectSync(name: string, interopConfig?: OpenFin.InteropConfig): InteropClient;
 }
 
+declare interface ItemConfig {
+    /**
+     * The type of the item. Possible values are 'row', 'column', 'stack', 'component' and 'react-component'.
+     */
+    type: ItemType;
+
+    /**
+     * An array of configurations for items that will be created as children of this item.
+     */
+    content?: ItemConfigType[];
+
+    /**
+     * The width of this item, relative to the other children of its parent in percent
+     */
+    width?: number;
+
+    /**
+     * The height of this item, relative to the other children of its parent in percent
+     */
+    height?: number;
+
+    /**
+     * A String or an Array of Strings. Used to retrieve the item using item.getItemsById()
+     */
+    id?: string | string[];
+
+    /**
+     * Determines if the item is closable. If false, the x on the items tab will be hidden and container.close()
+     * will return false
+     * Default: true
+     */
+    isClosable?: boolean;
+
+    /**
+     * The title of the item as displayed on its tab and on popout windows
+     * Default: componentName or ''
+     */
+    title?: string;
+}
+
+declare type ItemConfigType = ItemConfig | ComponentConfig | ReactComponentConfig;
+
+declare type ItemType = 'row' | 'column' | 'stack' | 'root' | 'component';
+
 /**
  * @interface
  */
@@ -6686,6 +7789,32 @@ declare type JumpListTask = {
     iconIndex?: number;
 };
 
+declare interface Labels {
+    /**
+     * The tooltip text that appears when hovering over the close icon.
+     * Default: 'close'
+     */
+    close?: string;
+
+    /**
+     * The tooltip text that appears when hovering over the maximise icon.
+     * Default: 'maximise'
+     */
+    maximise?: string;
+
+    /**
+     * The tooltip text that appears when hovering over the minimise icon.
+     * Default: 'minimise'
+     */
+    minimise?: string;
+
+    /**
+     * The tooltip text that appears when hovering over the popout icon.
+     * Default: 'open in new window'
+     */
+    popout?: string;
+}
+
 export declare function launch(config: ConnectConfig): Promise<number>;
 
 /**
@@ -6921,6 +8050,16 @@ declare class Layout extends Base {
      * ```
      */
     getConfig(): Promise<any>;
+    /**
+     * Retrieves the attached views in current window layout.
+     *
+     * @example
+     * ```js
+     * const layout = fin.Platform.Layout.getCurrentSync();
+     * const views = await layout.getCurrentViews();
+     * ```
+     */
+    getCurrentViews(): Promise<OpenFin.View[]>;
     /**
      * Replaces a Platform window's layout with a new layout.
      *
@@ -7191,6 +8330,7 @@ declare class LayoutManager {
     private setBackgroundImage;
     private setBackgroundImages;
     private getFrameSnapshot;
+    private getCurrentViews;
     private addView;
     private replaceView;
     private removeView;
@@ -7452,7 +8592,21 @@ declare type LayoutRow = LayoutItemConfig & {
  */
 declare type LegacyWinOptionsInAppOptions = Pick<WindowCreationOptions, 'accelerator' | 'alwaysOnTop' | 'api' | 'aspectRatio' | 'autoplayPolicy' | 'autoShow' | 'backgroundColor' | 'contentNavigation' | 'contextMenu' | 'cornerRounding' | 'customData' | 'customRequestHeaders' | 'defaultCentered' | 'defaultHeight' | 'defaultLeft' | 'defaultTop' | 'defaultWidth' | 'frame' | 'hideOnClose' | 'icon' | 'maxHeight' | 'maximizable' | 'maxWidth' | 'minHeight' | 'minimizable' | 'minWidth' | 'opacity' | 'preloadScripts' | 'resizable' | 'resizeRegion' | 'saveWindowState' | 'ignoreSavedWindowState' | 'shadow' | 'showTaskbarIcon' | 'smallWindow' | 'state' | 'taskbarIconGroup' | 'waitForPageLoad' | '_internalWorkspaceData'>;
 
-declare type Listener<T extends {
+declare interface Listener {
+    /**
+     * Unsubscribe the listener object.
+     */
+    unsubscribe(): void;
+}
+
+declare interface Listener_2 {
+    /**
+     * Unsubscribe the listener object.
+     */
+    unsubscribe(): void;
+}
+
+declare type Listener_3<T extends {
     type: string;
 }> = (payload: T) => void;
 
@@ -8192,6 +9346,10 @@ declare type Opacity = TransitionBase & {
     opacity: number;
 };
 
+declare type OpenExternalPermission = VerboseWebPermission & {
+    protocols: string[];
+};
+
 declare namespace OpenFin {
     export {
         FinApi,
@@ -8242,11 +9400,11 @@ declare namespace OpenFin {
         ApplicationOptions,
         InteropBrokerOptions,
         ContextGroupInfo,
-        DisplayMetadata,
+        DisplayMetadata_3 as DisplayMetadata,
         LegacyWinOptionsInAppOptions,
         Snapshot,
         ContextGroupStates,
-        Context,
+        Context_3 as Context,
         MonitorInfo,
         Point,
         PointTopLeft,
@@ -8311,6 +9469,8 @@ declare namespace OpenFin {
         LaunchExternalProcessRule,
         SystemPermissions,
         WebPermission,
+        VerboseWebPermission,
+        OpenExternalPermission,
         Permissions_2 as Permissions,
         PlatformWindowCreationOptions,
         PlatformWindowOptions,
@@ -8415,10 +9575,10 @@ declare namespace OpenFin {
         FileDownloadBehaviorNames,
         FileDownloadSettings,
         DownloadRule,
-        ContextHandler,
-        Intent,
-        IntentMetadata,
-        IntentHandler,
+        ContextHandler_3 as ContextHandler,
+        Intent_2 as Intent,
+        IntentMetadata_3 as IntentMetadata,
+        IntentHandler_2 as IntentHandler,
         ContentCreationBehaviorNames,
         MatchPattern,
         ContentCreationRule,
@@ -10265,6 +11425,14 @@ declare type PrintOptions = {
     dpi?: Dpi;
 };
 
+declare type PrivateChannel = Omit<Channel_4, 'addContextListener'> & {
+    addContextListener(contextType: string | null, handler: ContextHandler_2): Promise<Listener_2>;
+    onAddContextListener(handler: (contextType?: string) => void): Listener_2;
+    onUnsubscribe(handler: (contextType?: string) => void): Listener_2;
+    onDisconnect(handler: () => void): Listener_2;
+    disconnect(): void;
+};
+
 /**
  * Strategy to assign views to process affinity by domain.
  *
@@ -10717,6 +11885,18 @@ declare type QueryPermissionResult = {
     rawValue?: unknown;
 };
 
+declare interface ReactComponentConfig extends ItemConfig {
+    /**
+     * The name of the component as specified in layout.registerComponent. Mandatory if type is 'react-component'
+     */
+    component: string;
+
+    /**
+     * Properties that will be passed to the component and accessible using this.props.
+     */
+    props?: any;
+}
+
 /**
  * @interface
  */
@@ -11177,23 +12357,114 @@ declare type SessionContextGroup = {
      * A SessionContextGroup instance method for setting a context in the SessionContextGroup.
      * @param context The Context to be set.
      */
-    setContext: (context: Context) => Promise<void>;
+    setContext: (context: Context_3) => Promise<void>;
     /**
      * A SessionContextGroup instance method for getting the current context of a certain type.
      * @param type The Context Type to get. If not specified the last contextType set would get used.
      */
-    getCurrentContext: (type?: string) => Promise<Context>;
+    getCurrentContext: (type?: string) => Promise<Context_3>;
     /**
      * A SessionContextGroup instance method for adding a handler for context change.
      * @param handler 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.
      *
      */
-    addContextHandler: (handler: ContextHandler, contextType?: string) => Promise<{
+    addContextHandler: (handler: ContextHandler_3, contextType?: string) => Promise<{
         unsubscribe: () => void;
     }>;
 };
 
+declare interface Settings {
+    preventSplitterResize?: boolean;
+
+    newTabButton?: {
+        url?: string;
+    };
+
+    /**
+     * If true, tabs can't be dragged into the window.
+     * Default: false
+     */
+    preventDragIn?: boolean;
+
+    /**
+     * If true, tabs can't be dragged out of the window.
+     * Default: false
+     */
+    preventDragOut?: boolean;
+
+    /**
+     * If true, stack headers are the only areas where tabs can be dropped.
+     * Default: false
+     */
+    constrainDragToHeaders?: boolean;
+    /**
+     * Turns headers on or off. If false, the layout will be displayed with splitters only.
+     * Default: true
+     */
+    hasHeaders?: boolean;
+
+    /**
+     * (Unused in Openfin Platform) Constrains the area in which items can be dragged to the layout's container. Will be set to false
+     * automatically when layout.createDragSource() is called.
+     * Default: true
+     */
+    constrainDragToContainer?: boolean;
+
+    /**
+     * If true, the user can re-arrange the layout by dragging items by their tabs to the desired location.
+     * Default: true
+     */
+    reorderEnabled?: boolean;
+
+    /**
+     * If true, the user can select items by clicking on their header. This sets the value of layout.selectedItem to
+     * the clicked item, highlights its header and the layout emits a 'selectionChanged' event.
+     * Default: false
+     */
+    selectionEnabled?: boolean;
+
+    /**
+     * Decides what will be opened in a new window if the user clicks the popout icon. If true the entire stack will
+     * be transferred to the new window, if false only the active component will be opened.
+     * Default: false
+     */
+    popoutWholeStack?: boolean;
+
+    /**
+     * Specifies if an error is thrown when a popout is blocked by the browser (e.g. by opening it programmatically).
+     * If false, the popout call will fail silently.
+     * Default: true
+     */
+    blockedPopoutsThrowError?: boolean;
+
+    /**
+     * Specifies if all popouts should be closed when the page that created them is closed. Popouts don't have a
+     * strong dependency on their parent and can exist on their own, but can be quite annoying to close by hand. In
+     * addition, any changes made to popouts won't be stored after the parent is closed.
+     * Default: true
+     */
+    closePopoutsOnUnload?: boolean;
+
+    /**
+     * Specifies if the popout icon should be displayed in the header-bar.
+     * Default: true
+     */
+    showPopoutIcon?: boolean;
+
+    /**
+     * Specifies if the maximise icon should be displayed in the header-bar.
+     * Default: true
+     */
+    showMaximiseIcon?: boolean;
+
+    /**
+     * Specifies if the close icon should be displayed in the header-bar.
+     * Default: true
+     */
+    showCloseIcon?: boolean;
+}
+
 /**
  * @interface
  */
@@ -12936,6 +14207,12 @@ declare class System extends EmitterBase<OpenFin.SystemEvent> {
     setDomainSettings(domainSettings: OpenFin.DefaultDomainSettings): Promise<void>;
 }
 
+declare type SystemChannel = Omit<Channel_3, 'addContextListener' | 'broadcast' | 'getCurrentContext'> & {
+    addContextListener(): Error;
+    broadcast(): Error;
+    getCurrentContext(): Error;
+};
+
 /**
  *  [Union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types) containing every possible event that can be emitted by a {@link System}.  Events are
  *  discriminated by {@link SystemEvent.type | their type}.  Event payloads unique to `System` can be found
@@ -13021,6 +14298,52 @@ declare type SystemShutdownHandler = (shutdownEvent: {
     proceed: () => void;
 }) => void;
 
+declare interface Tab {
+    _dragListener: EventEmitter_2;
+
+    /**
+     * True if this tab is the selected tab
+     */
+    isActive: boolean;
+
+    /**
+     * A reference to the header this tab is a child of
+     */
+    header: Header;
+
+    /**
+     * A reference to the content item this tab relates to
+     */
+    contentItem: ContentItem;
+
+    /**
+     * The tabs outer (jQuery) DOM element
+     */
+    element: JQuery;
+
+    /**
+     * The (jQuery) DOM element containing the title
+     */
+    titleElement: JQuery;
+
+    /**
+     * The (jQuery) DOM element that closes the tab
+     */
+    closeElement: JQuery;
+
+    /**
+     * Sets the tab's title. Does not affect the contentItem's title!
+     * @param title The new title
+     */
+    setTitle(title: string): void;
+
+    /**
+     * Sets this tab's active state. To programmatically switch tabs, use header.setActiveContentItem( item ) instead.
+     * @param isActive Whether the tab is active
+     */
+    setActive(isActive: boolean): void;
+}
+
 /**
  * Set of apis used to facilitate tab drag interactions without needing to hide views.
  * @ignore
@@ -13408,13 +14731,13 @@ declare type tween = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'ease-i
 declare interface TypedEventEmitter<Event extends {
     type: string;
 }, EmitterEventType = Event['type']> {
-    on<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+    on<EventType extends EmitterEventType>(event: EventType, listener: Listener_3<Extract<Event, {
         type: EventType;
     }>>): this;
-    addListener<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+    addListener<EventType extends EmitterEventType>(event: EventType, listener: Listener_3<Extract<Event, {
         type: EventType;
     }>>): this;
-    removeListener<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+    removeListener<EventType extends EmitterEventType>(event: EventType, listener: Listener_3<Extract<Event, {
         type: EventType;
     }>>): this;
     removeAllListeners<EventType extends EmitterEventType>(event?: EmitterEventType): this;
@@ -13485,6 +14808,53 @@ declare type UserMovementEnabledEvent = NamedEvent & {
     type: 'user-movement-enabled';
 };
 
+declare namespace v1 {
+    export {
+        Listener,
+        AppMetadata,
+        IntentMetadata,
+        AppIntent,
+        DisplayMetadata,
+        ImplementationMetadata,
+        ContextHandler,
+        TargetApp,
+        Context,
+        IntentResolution,
+        Channel_3 as Channel,
+        SystemChannel,
+        DesktopAgent
+    }
+}
+
+declare namespace v2 {
+    export {
+        IntentMetadata_2 as IntentMetadata,
+        AppIdentifier,
+        Listener_2 as Listener,
+        AppIntent_2 as AppIntent,
+        ImplementationMetadata_2 as ImplementationMetadata,
+        ContextMetadata,
+        Icon,
+        Image_2 as Image,
+        AppMetadata_2 as AppMetadata,
+        DisplayMetadata_2 as DisplayMetadata,
+        ContextHandler_2 as ContextHandler,
+        IntentHandler,
+        IntentResult,
+        Context_2 as Context,
+        Intent,
+        IntentResolution_2 as IntentResolution,
+        Channel_4 as Channel,
+        PrivateChannel,
+        DesktopAgent_2 as DesktopAgent
+    }
+}
+
+declare type VerboseWebPermission = {
+    api: string;
+    enabled: boolean;
+};
+
 declare type View = OpenFin.View;
 
 /**
@@ -15331,7 +16701,7 @@ declare namespace WebContentsEvents {
  * `clipboard-read`: Request access to read from the clipboard.<br>
  * `clipboard-sanitized-write`: Request access to write to the clipboard.
  */
-declare type WebPermission = 'audio' | 'video' | 'geolocation' | 'notifications' | 'midiSysex' | 'pointerLock' | 'fullscreen' | 'openExternal' | 'clipboard-read' | 'clipboard-sanitized-write';
+declare type WebPermission = 'audio' | 'video' | 'geolocation' | 'notifications' | 'midiSysex' | 'pointerLock' | 'fullscreen' | 'openExternal' | 'clipboard-read' | 'clipboard-sanitized-write' | OpenExternalPermission;
 
 /**
  * Object representing headers and their values, where the