@openfin/fdc3-api 37.81.30 → 38.81.22

package/out/fdc3-api.d.ts

@@ -940,7 +940,7 @@ declare type ApplicationIdentity_2 = {
  * @interface
  */
 declare type ApplicationInfo = {
-    initialOptions: WithUserAppConfigArgs & (ApplicationCreationOptions | PlatformOptions);
+    initialOptions: ApplicationCreationOptions | PlatformOptions;
     launchMode: string;
     manifest: Manifest & {
         [key: string]: any;
@@ -1167,14 +1167,9 @@ declare type ApplicationOptions = LegacyWinOptionsInAppOptions & {
      */
     mainWindowOptions: WindowCreationOptions;
     /**
-     * The name of the application.
+     * The name of the application (and the application's main window).
      *
-     * @remarks
-     * This property is only used for naming the application logging folder, which will be sanitized to remove
-     * any special characters, spaces or international characters. Otherwise it's not used and it will be overwritten
-     * during startup with the UUID of the application.
-     *
-     * This property will be deprecated in the future.
+     * If provided, _must_ match `uuid`.
      */
     name: string;
     /**
@@ -1204,7 +1199,9 @@ declare type ApplicationOptions = LegacyWinOptionsInAppOptions & {
     url: string;
     /**
      * The _Unique Universal Identifier_ (UUID) of the application, unique within the set of all other applications
-     * running in the OpenFin Runtime.
+     *  running in the OpenFin Runtime.
+     *
+     * Note that `name` and `uuid` must match.
      */
     uuid: string;
     /**
@@ -1939,6 +1936,48 @@ declare type BrowserContentCreationRule = BaseContentCreationRule & {
     behavior: 'browser';
 };
 
+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;
+}
+
 /**
  * Extracts a single event type matching the given key from the View {@link Event} union.
  *
@@ -2011,6 +2050,15 @@ declare type ByType_7<Type extends EventType_7> = Payload_8<Type>;
  */
 declare type ByType_8<Type extends EventType_8> = Payload_9<Type>;
 
+/**
+ * Extracts a single event type matching the given key from the Layout DOM {@link Event} union.
+ *
+ * Alias for {@link Payload}, which may read better in source.
+ *
+ * @typeParam Type String key specifying the event to extract
+ */
+declare type ByType_9<Type extends EventType_9> = Payload_10<Type>;
+
 /**
  * Configuration for page capture.
  *
@@ -3337,6 +3385,31 @@ declare class ColumnOrRow extends LayoutNode {
     getContent: () => Promise<(ColumnOrRow | TabStack)[]>;
 }
 
+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;
 };
@@ -3714,6 +3787,111 @@ declare type ConstWindowOptions = {
     inheritance?: Partial<InheritableOptions>;
 };
 
+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;
+}
+
+/**
+ * Generated when a Layout Container Component was created.
+ * @interface
+ */
+declare type ContainerCreatedEvent = LayoutDOMEvent & {
+    type: 'container-created';
+};
+
 /**
  * Generated when content navigation or redirection is blocked by {@link OpenFin.DomainSettings}.
  */
@@ -3787,6 +3965,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.
@@ -4214,6 +4604,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
  */
@@ -4306,7 +4736,14 @@ declare type DomainApiSettings = {
      *
      * @defaultValue 'global'
      */
-    fin: InjectionType;
+    fin?: InjectionType;
+    /**
+     * API permissions for domains matched to the current {@link DomainSettingsRule}.
+     *
+     * @remarks If an application manifest includes this property in {@link DomainSettings.default},
+     * then {@link WindowOptions.permissions} and {@link ViewOptions.permissions} will be **ignored**.
+     */
+    permissions?: Permissions_2;
 };
 
 /**
@@ -4463,6 +4900,8 @@ declare type Dpi = {
     vertical?: number;
 };
 
+declare interface DragSource {}
+
 /**
  * Generated when a window has been embedded.
  * @interface
@@ -4643,6 +5082,7 @@ declare type EntityTypeHelpers<T extends EntityType_2> = T extends 'view' ? {
 } : never;
 
 declare interface Environment {
+    layoutAllowedInContext(fin: OpenFin.Fin<OpenFin.EntityType>): boolean;
     initLayoutManager(fin: OpenFin.Fin<OpenFin.EntityType>, wire: Transport, options: OpenFin.InitLayoutOptions): Promise<OpenFin.LayoutManager<OpenFin.LayoutSnapshot>>;
     applyLayoutSnapshot(fin: OpenFin.Fin<OpenFin.EntityType>, layoutManager: OpenFin.LayoutManager<OpenFin.LayoutSnapshot>, options: OpenFin.InitLayoutOptions): Promise<void>;
     createLayout(layoutManager: OpenFin.LayoutManager<OpenFin.LayoutSnapshot>, options: OpenFin.CreateLayoutOptions): Promise<void>;
@@ -4705,6 +5145,12 @@ declare type Event_10 = ApplicationEvents.Event | ApiReadyEvent | SnapshotApplie
  */
 declare type Event_11 = ExcludeRequested<WindowEvents.PropagatedEvent<'system'>> | ExcludeRequested<ViewEvents.PropagatedEvent<'system'>> | ExcludeRequested<ApplicationEvents.PropagatedEvent<'system'>> | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleStateChangedEvent | MonitorInfoChangedEvent | SessionChangedEvent | AppVersionEventWithId | SystemShutdownEvent;
 
+/**
+ * [Union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types) containing every possible event that can be emitted by the HTMLElement Layout container.
+ * Events are discriminated by {@link LayoutDOMEvent.type}.
+ */
+declare type Event_12 = TabCreatedEvent | TabClosedEvent | TabDroppedEvent | ContainerCreatedEvent | LayoutStateChangedEvent;
+
 /**
  * [Union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types) containing every possible event that can be emitted by a {@link Channel}.  Events are
  * discriminated by {@link BaseEvents.BaseEvent.type | their type}.  Event payloads unique to `Channel` can be found
@@ -4773,6 +5219,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
@@ -4837,6 +5320,11 @@ declare type EventType_7 = Event_10['type'];
  */
 declare type EventType_8 = Event_11['type'];
 
+/**
+ * Union of possible `type` values for a {@link LayoutDOMEvent}.
+ */
+declare type EventType_9 = Event_12['type'];
+
 /**
  * @internal
  */
@@ -5364,7 +5852,6 @@ declare class FDC3ModuleBase<ChannelType extends v1_2.Channel | v2_0.Channel> {
      * @tutorial fdc3.open
      */
     protected _open(app: v1_2.TargetApp, context?: v1_2.Context): Promise<v2_0.AppIdentifier>;
-    protected _getChannels(): Promise<ChannelType[]>;
     /**
      * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
      * @param channelId
@@ -5933,51 +6420,298 @@ declare class GlobalHotkey extends EmitterBase<OpenFin.GlobalHotkeyEvent> {
      */
     unregisterAll(): Promise<void>;
     /**
-     * Checks if a given hotkey has been registered by an application within the current runtime.
-     * @param hotkey a hotkey string
-     *
-     * @example
-     * ```js
-     * const hotkey = 'CommandOrControl+X';
-     *
-     * fin.GlobalHotkey.isRegistered(hotkey)
-     * .then((registered) => {
-     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);
-     * })
-     * .catch(err => {
-     *     console.log('Error unregistering the hotkey', err);
-     * });
-     * ```
+     * Checks if a given hotkey has been registered by an application within the current runtime.
+     * @param hotkey a hotkey string
+     *
+     * @example
+     * ```js
+     * const hotkey = 'CommandOrControl+X';
+     *
+     * fin.GlobalHotkey.isRegistered(hotkey)
+     * .then((registered) => {
+     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);
+     * })
+     * .catch(err => {
+     *     console.log('Error unregistering the hotkey', err);
+     * });
+     * ```
+     */
+    isRegistered(hotkey: string): Promise<boolean>;
+}
+
+/**
+ * @deprecated Renamed to {@link Event}.
+ */
+declare type GlobalHotkeyEvent = Event_9;
+
+declare type GlobalHotkeyEvent_2 = Events.GlobalHotkeyEvents.GlobalHotkeyEvent;
+
+declare namespace GlobalHotkeyEvents {
+    export {
+        BaseEvent_8 as BaseEvent,
+        RegisteredEvent,
+        UnregisteredEvent,
+        Event_9 as Event,
+        GlobalHotkeyEvent,
+        EventType_6 as EventType,
+        GlobalHotkeyEventType,
+        Payload_7 as Payload,
+        ByType_6 as ByType
+    }
+}
+
+/**
+ * @deprecated Renamed to {@link EventType}.
+ */
+declare type GlobalHotkeyEventType = EventType_6;
+
+declare namespace GoldenLayout {
+    export {
+        GoldenLayout_2 as GoldenLayout,
+        ItemConfigType,
+        Settings,
+        Dimensions,
+        Labels,
+        ItemType,
+        ItemConfig,
+        ComponentConfig,
+        ReactComponentConfig,
+        Config,
+        ContentItem,
+        Container,
+        DragSource,
+        BrowserWindow,
+        Header,
+        TabDragListener,
+        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;
+
+    _isFullPage: boolean;
+
+    _onUnload: any;
+
+    tabDropPlaceholder: any;
+
+    transitionIndicator: any;
+
+    _dragSources: any;
+
+    _resizeFunction: any;
+
+    _unloadFunction: 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;
+
+    /**
+     * 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
      */
-    isRegistered(hotkey: string): Promise<boolean>;
-}
+    trigger(eventName: string, arg1?: any, arg2?: any, ...argN: any[]): void;
 
-/**
- * @deprecated Renamed to {@link Event}.
- */
-declare type GlobalHotkeyEvent = Event_9;
+    /**
+     * 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;
 
-declare type GlobalHotkeyEvent_2 = Events.GlobalHotkeyEvents.GlobalHotkeyEvent;
+    /**
+     * Alias for unbind
+     */
+    off(eventName: string, callback?: Function, context?: any): void;
 
-declare namespace GlobalHotkeyEvents {
-    export {
-        BaseEvent_8 as BaseEvent,
-        RegisteredEvent,
-        UnregisteredEvent,
-        Event_9 as Event,
-        GlobalHotkeyEvent,
-        EventType_6 as EventType,
-        GlobalHotkeyEventType,
-        Payload_7 as Payload,
-        ByType_6 as ByType
-    }
+    /**
+     * Internal method that create drop areas on the far edges of window, e.g. far-right of window
+     */
+    _$createRootItemAreas(): void;
 }
 
-/**
- * @deprecated Renamed to {@link EventType}.
- */
-declare type GlobalHotkeyEventType = EventType_6;
-
 /**
  * @interface
  */
@@ -5985,6 +6719,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
@@ -7210,7 +8000,9 @@ declare class InteropClient extends Base {
      * ```
      *
      *
-     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.
+     * We are also testing the ability to add a context handler for specific contexts. If you would like to use
+     * this, please make sure you add your context handlers at the top level of your application, on a page that
+     * does not navigate/reload/re-render, to avoid memory leaks.  This feature is experimental:
      *
      * ```js
      * function handleInstrumentContext(contextInfo) {
@@ -7597,6 +8389,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
  */
@@ -7654,6 +8490,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;
+}
+
 /**
  * The LaunchEmitter is an `EventEmitter`. It can listen to app version resolver events.
  *
@@ -8052,6 +8914,32 @@ declare type LayoutComponent = LayoutItemConfig & {
 
 declare type LayoutContent = Array<LayoutItemConfig | LayoutRow | LayoutColumn | LayoutComponent>;
 
+/**
+ * The base payload for the CustomEvent.detail property for Layout events emitted on the layout container element.
+ */
+declare type LayoutDOMEvent = Identity_5 & {
+    type: string;
+    topic: 'openfin-DOM-event';
+    tabSelector: string;
+    containerSelector: string;
+};
+
+declare type LayoutDOMEvent_2 = LayoutDOMEvents.Event;
+
+declare namespace LayoutDOMEvents {
+    export {
+        TabCreatedEvent,
+        TabClosedEvent,
+        TabDroppedEvent,
+        ContainerCreatedEvent,
+        LayoutStateChangedEvent,
+        Event_12 as Event,
+        EventType_9 as EventType,
+        Payload_10 as Payload,
+        ByType_9 as ByType
+    }
+}
+
 declare type LayoutEntitiesClient = ApiClient<LayoutEntitiesController>;
 
 declare type LayoutEntitiesController = {
@@ -8085,7 +8973,7 @@ declare type LayoutEntityDefinition<TLayoutEntityType extends LayoutEntityTypes
     entityId: string;
 };
 
-declare type LayoutEntityTypes = 'column' | 'row' | 'stack';
+declare type LayoutEntityTypes = Exclude<GoldenLayout.ItemType, 'component' | 'root'>;
 
 /**
  * @interface
@@ -8667,6 +9555,14 @@ declare type LayoutSnapshot = {
     layouts: Record<string, LayoutOptions>;
 };
 
+/**
+ * Generated when the Layout experiences a state change, for example tabs added/removed.
+ * @interface
+ */
+declare type LayoutStateChangedEvent = LayoutDOMEvent & {
+    type: 'layout-state-changed';
+};
+
 /**
  * @interface
  */
@@ -9651,7 +10547,6 @@ declare namespace OpenFin {
         AppVersionError,
         AppVersionRuntimeInfo,
         LaunchEmitter,
-        UserAppConfigArgs,
         RvmLaunchOptions,
         ShortCutConfig,
         TerminateExternalRequestType,
@@ -9777,6 +10672,7 @@ declare namespace OpenFin {
         AppVersionCompleteEvent,
         AppVersionRuntimeStatusEvent,
         Events,
+        LayoutDOMEvents,
         BaseEvent_10 as BaseEvent,
         WebContentsEvent_2 as WebContentsEvent,
         SystemEvent_2 as SystemEvent,
@@ -9785,6 +10681,7 @@ declare namespace OpenFin {
         ViewEvent_2 as ViewEvent,
         GlobalHotkeyEvent_2 as GlobalHotkeyEvent,
         FrameEvent_2 as FrameEvent,
+        LayoutDOMEvent_2 as LayoutDOMEvent,
         PlatformEvent_2 as PlatformEvent,
         ExternalApplicationEvent_2 as ExternalApplicationEvent,
         ContextMenuOptions,
@@ -9857,6 +10754,15 @@ declare type Payload<Success extends boolean = boolean, Data = any> = {
     error?: Success extends false ? ErrorPlainObject | undefined : never;
 };
 
+/**
+ * Extracts a single event type matching the given key from the Layout DOM {@link Event} union.
+ *
+ * @typeParam Type String key specifying the event to extract
+ */
+declare type Payload_10<Type extends EventType_9> = Extract<Event_12, {
+    type: Type;
+}>;
+
 /**
  * Extracts a single event type matching the given key from the View {@link Event} union.
  *
@@ -9964,6 +10870,14 @@ declare type PerformanceReportEvent = Performance & BaseEvent_5 & {
 
 /**
  * @interface
+ *
+ * Governs access to OpenFin APIs.  Property paths of this literal match call
+ * paths for OpenFin API functions (e.g. `System.launchExternalProcess`), and can
+ * take a value of `true`, `false`, or in some cases an object literal for more-complicated
+ * semantics.
+ *
+ * For a list of APIs that are secure by default (and thus must be granted access via
+ * `permissions`), see https://developers.openfin.co/of-docs/docs/api-security#secured-apis.
  */
 declare type Permissions_2 = {
     Application?: Partial<ApplicationPermissions>;
@@ -12262,6 +13176,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
  */
@@ -12524,7 +13450,7 @@ declare type RunRequestedEvent = OpenFin.ApplicationEvents.RunRequestedEvent;
 declare type RunRequestedEvent_2 = BaseEvents.IdentityEvent & {
     topic: 'application';
     type: 'run-requested';
-    userAppConfigArgs: OpenFin.UserAppConfigArgs;
+    userAppConfigArgs: Record<string, any>;
     manifest: OpenFin.Manifest;
 };
 
@@ -12639,7 +13565,7 @@ declare type RvmLaunchOptions = {
      * True if no UI when launching
      */
     noUi?: boolean;
-    userAppConfigArgs?: UserAppConfigArgs;
+    userAppConfigArgs?: object;
     /**
      * Timeout in seconds until RVM launch request expires.
      */
@@ -12738,6 +13664,97 @@ declare type SessionContextGroup = {
     }>;
 };
 
+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
  */
@@ -14640,6 +15657,85 @@ declare type SystemShutdownHandler = (shutdownEvent: {
     proceed: () => void;
 }) => void;
 
+declare interface Tab {
+    _dragListener: TabDragListener;
+
+    /**
+     * 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;
+}
+
+/**
+ * Generated when a Layout Tab Component was closed.
+ * @interface
+ */
+declare type TabClosedEvent = LayoutDOMEvent & {
+    type: 'tab-closed';
+    url: string;
+};
+
+/**
+ * Generated when a Layout Tab Component was created.
+ * @interface
+ */
+declare type TabCreatedEvent = LayoutDOMEvent & {
+    type: 'tab-created';
+};
+
+declare interface TabDragListener extends EventEmitter_2 {
+    /**
+     * A reference to the content item this tab relates to
+     */
+    contentItem: ContentItem;
+}
+
+/**
+ * Generated when a Layout Tab Component was dropped.
+ * @interface
+ */
+declare type TabDroppedEvent = LayoutDOMEvent & {
+    type: 'tab-dropped';
+    url: string;
+};
+
 /**
  * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
  */
@@ -15006,11 +16102,6 @@ declare type UrlChangedEvent = BaseUrlEvent & ({
     httpStatusText: string;
 });
 
-/**
- * @interface
- */
-declare type UserAppConfigArgs = Record<string, string | string[]>;
-
 /**
  * A general user bounds change event without event type.
  * @interface
@@ -18443,32 +19534,6 @@ declare type WithPositioningOptions<T extends {} = {}> = T & {
     positioningOptions?: OpenFin.PositioningOptions;
 };
 
-declare type WithUserAppConfigArgs = {
-    /**
-     * Represents the key-value pairs for the parameters passed into any fin:// or fins:// link
-     * that launches this application.
-     *
-     * @remarks
-     * In the link, user defined parameters are separated by the `$$` delimeter, for example:
-     * `fins://path.to/app/manifest.json?$$use-last-configuration=true`
-     *
-     * Results in the following object:
-     * ```json
-     * {
-     *    "use-last-configuration": true"
-     * }
-     * ```
-     *
-     * These args can be accessed via the {@link ApplicationInfo.initialOptions} object:
-     * ```typescript
-     * const appInfo = await fin.Application.getCurrentSync().getInfo();
-     * const { userAppConfigArgs } = appInfo.initialOptions;
-     * console.log(userAppConfigArgs['use-last-configuration']); // 'true'
-     * ```
-     */
-    userAppConfigArgs?: UserAppConfigArgs;
-};
-
 /**
  * @internal
  * @interface