@genesis-community/golden-layout 2.6.0

package/dist/types/index.d.ts

@@ -0,0 +1,2246 @@
+/** @public */
+export declare class ApiError extends ExternalError {
+    /* Excluded from this release type: __constructor */
+}
+
+/* Excluded from this release type: AreaLinkedRect */
+
+/** @public */
+export declare class BindError extends ExternalError {
+    /* Excluded from this release type: __constructor */
+}
+
+/**
+ * Pops a content item out into a new browser window.
+ * This is achieved by
+ *
+ *    - Creating a new configuration with the content item as root element
+ *    - Serializing and minifying the configuration
+ *    - Opening the current window's URL with the configuration as a GET parameter
+ *    - GoldenLayout when opened in the new window will look for the GET parameter
+ *      and use it instead of the provided configuration
+ * @public
+ */
+export declare class BrowserPopout extends EventEmitter {
+    /* Excluded from this release type: _config */
+    /* Excluded from this release type: _initialWindowSize */
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _popoutWindow */
+    /* Excluded from this release type: _isInitialised */
+    /* Excluded from this release type: _checkReadyInterval */
+    /* Excluded from this release type: __constructor */
+    toConfig(): ResolvedPopoutLayoutConfig;
+    getGlInstance(): LayoutManager;
+    /**
+     * Retrieves the native BrowserWindow backing this popout.
+     * Might throw an UnexpectedNullError exception when the window is not initialized yet.
+     * @public
+     */
+    getWindow(): Window;
+    close(): void;
+    /**
+     * Returns the popped out item to its original position. If the original
+     * parent isn't available anymore it falls back to the layout's topmost element
+     */
+    popIn(): void;
+    /* Excluded from this release type: createWindow */
+    /* Excluded from this release type: checkReady */
+    /* Excluded from this release type: serializeWindowFeatures */
+    /* Excluded from this release type: createUrl */
+    /* Excluded from this release type: positionWindow */
+    /* Excluded from this release type: onInitialised */
+    /* Excluded from this release type: _onClose */
+}
+
+/** @public */
+export declare class ComponentContainer extends EventEmitter {
+    /* Excluded from this release type: _config */
+    /* Excluded from this release type: _parent */
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _element */
+    /* Excluded from this release type: _updateItemConfigEvent */
+    /* Excluded from this release type: _showEvent */
+    /* Excluded from this release type: _hideEvent */
+    /* Excluded from this release type: _focusEvent */
+    /* Excluded from this release type: _blurEvent */
+    /* Excluded from this release type: _componentType */
+    /* Excluded from this release type: _boundComponent */
+    /* Excluded from this release type: _width */
+    /* Excluded from this release type: _height */
+    /* Excluded from this release type: _isClosable */
+    /* Excluded from this release type: _initialState */
+    /* Excluded from this release type: _state */
+    /* Excluded from this release type: _visible */
+    /* Excluded from this release type: _isShownWithZeroDimensions */
+    /* Excluded from this release type: _tab */
+    /* Excluded from this release type: _stackMaximised */
+    /* Excluded from this release type: _logicalZIndex */
+    stateRequestEvent: ComponentContainer.StateRequestEventHandler | undefined;
+    virtualRectingRequiredEvent: ComponentContainer.VirtualRectingRequiredEvent | undefined;
+    virtualVisibilityChangeRequiredEvent: ComponentContainer.VirtualVisibilityChangeRequiredEvent | undefined;
+    virtualZIndexChangeRequiredEvent: ComponentContainer.VirtualZIndexChangeRequiredEvent | undefined;
+    get width(): number;
+    get height(): number;
+    get parent(): ComponentItem;
+    /* Excluded from this release type: componentName */
+    get componentType(): JsonValue;
+    get virtual(): boolean;
+    get component(): ComponentContainer.Component;
+    get tab(): Tab;
+    get title(): string;
+    get layoutManager(): LayoutManager;
+    get isHidden(): boolean;
+    get visible(): boolean;
+    get state(): JsonValue | undefined;
+    /** Return the initial component state */
+    get initialState(): JsonValue | undefined;
+    /** The inner DOM element where the container's content is intended to live in */
+    get element(): HTMLElement;
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: destroy */
+    /** @deprecated use {@link (ComponentContainer:class).element } */
+    getElement(): HTMLElement;
+    /**
+     * Hides the container's component item (and hence, the container) if not already hidden.
+     * Emits hide event prior to hiding the container.
+     */
+    hide(): void;
+    /**
+     * Shows the container's component item (and hence, the container) if not visible.
+     * Emits show event prior to hiding the container.
+     */
+    show(): void;
+    /**
+     * Focus this component in Layout.
+     */
+    focus(suppressEvent?: boolean): void;
+    /**
+     * Remove focus from this component in Layout.
+     */
+    blur(suppressEvent?: boolean): void;
+    /* Excluded from this release type: setSize */
+    /**
+     * Closes the container if it is closable. Can be called by
+     * both the component within at as well as the contentItem containing
+     * it. Emits a close event before the container itself is closed.
+     */
+    close(): void;
+    /** Replaces component without affecting layout */
+    replaceComponent(itemConfig: ComponentItemConfig): void;
+    /**
+     * Returns the initial component state or the latest passed in setState()
+     * @returns state
+     * @deprecated Use {@link (ComponentContainer:class).initialState}
+     */
+    getState(): JsonValue | undefined;
+    /**
+     * Merges the provided state into the current one
+     * @deprecated Use {@link (ComponentContainer:class).stateRequestEvent}
+     */
+    extendState(state: Record<string, unknown>): void;
+    /**
+     * Sets the component state
+     * @deprecated Use {@link (ComponentContainer:class).stateRequestEvent}
+     */
+    setState(state: JsonValue): void;
+    /**
+     * Set's the components title
+     */
+    setTitle(title: string): void;
+    /* Excluded from this release type: setTab */
+    /* Excluded from this release type: setVisibility */
+    setBaseLogicalZIndex(): void;
+    setLogicalZIndex(logicalZIndex: LogicalZIndex): void;
+    /* Excluded from this release type: enterDragMode */
+    /* Excluded from this release type: exitDragMode */
+    /* Excluded from this release type: enterStackMaximised */
+    /* Excluded from this release type: exitStackMaximised */
+    /* Excluded from this release type: drag */
+    /* Excluded from this release type: setSizeToNodeSize */
+    /* Excluded from this release type: notifyVirtualRectingRequired */
+    /* Excluded from this release type: notifyVirtualZIndexChangeRequired */
+    /* Excluded from this release type: updateElementPositionPropertyFromBoundComponent */
+    /* Excluded from this release type: addVirtualSizedContainerToLayoutManager */
+    /* Excluded from this release type: checkShownFromZeroDimensions */
+    /* Excluded from this release type: emitShow */
+    /* Excluded from this release type: emitHide */
+    /* Excluded from this release type: releaseComponent */
+}
+
+/** @public */
+export declare namespace ComponentContainer {
+    export type Component = unknown;
+    export interface BindableComponent {
+        component: Component;
+        virtual: boolean;
+    }
+    export type StateRequestEventHandler = (this: void) => JsonValue | undefined;
+    export type VirtualRectingRequiredEvent = (this: void, container: ComponentContainer, width: number, height: number) => void;
+    export type VirtualVisibilityChangeRequiredEvent = (this: void, container: ComponentContainer, visible: boolean) => void;
+    export type VirtualZIndexChangeRequiredEvent = (this: void, container: ComponentContainer, logicalZIndex: LogicalZIndex, defaultZIndex: string) => void;
+    /* Excluded from this release type: ShowEventHandler */
+    /* Excluded from this release type: HideEventHandler */
+    /* Excluded from this release type: FocusEventHandler */
+    /* Excluded from this release type: BlurEventHandler */
+    /* Excluded from this release type: UpdateItemConfigEventHandler */
+}
+
+/** @public */
+export declare class ComponentItem extends ContentItem {
+    /* Excluded from this release type: _parentItem */
+    /* Excluded from this release type: _reorderEnabled */
+    /* Excluded from this release type: _headerConfig */
+    /* Excluded from this release type: _title */
+    /* Excluded from this release type: _initialWantMaximise */
+    /* Excluded from this release type: _container */
+    /* Excluded from this release type: _tab */
+    /* Excluded from this release type: _focused */
+    /* Excluded from this release type: componentName */
+    get componentType(): JsonValue;
+    get reorderEnabled(): boolean;
+    /* Excluded from this release type: initialWantMaximise */
+    get component(): ComponentContainer.Component | undefined;
+    get container(): ComponentContainer;
+    get parentItem(): ComponentParentableItem;
+    get headerConfig(): ResolvedHeaderedItemConfig.Header | undefined;
+    get title(): string;
+    get tab(): Tab;
+    get focused(): boolean;
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: destroy */
+    applyUpdatableConfig(config: ResolvedComponentItemConfig): void;
+    toConfig(): ResolvedComponentItemConfig;
+    close(): void;
+    /* Excluded from this release type: enterDragMode */
+    /* Excluded from this release type: exitDragMode */
+    /* Excluded from this release type: enterStackMaximised */
+    /* Excluded from this release type: exitStackMaximised */
+    /* Excluded from this release type: drag */
+    /* Excluded from this release type: updateSize */
+    /* Excluded from this release type: init */
+    /**
+     * Set this component's title
+     *
+     * @public
+     * @param title -
+     */
+    setTitle(title: string): void;
+    setTab(tab: Tab): void;
+    /* Excluded from this release type: hide */
+    /* Excluded from this release type: show */
+    /**
+     * Focuses the item if it is not already focused
+     */
+    focus(suppressEvent?: boolean): void;
+    /* Excluded from this release type: setFocused */
+    /**
+     * Blurs (defocuses) the item if it is focused
+     */
+    blur(suppressEvent?: boolean): void;
+    /* Excluded from this release type: setBlurred */
+    /* Excluded from this release type: setParent */
+    /* Excluded from this release type: handleUpdateItemConfigEvent */
+    /* Excluded from this release type: updateNodeSize */
+}
+
+/** @public */
+export declare namespace ComponentItem {
+    export type Component = ComponentContainer.Component;
+}
+
+/** @public */
+export declare interface ComponentItemConfig extends HeaderedItemConfig {
+    type: 'component';
+    readonly content?: [];
+    /**
+     * The title of the item as displayed on its tab and on popout windows
+     * Default: componentType.toString() or ''
+     */
+    title?: string;
+    /**
+     * The type of the component.
+     * @deprecated use {@link (ComponentItemConfig:interface).componentType} instead
+     */
+    componentName?: string;
+    /**
+     * The type of the component.
+     * `componentType` must be of type `string` if it is registered with any of the following functions:
+     * * {@link (GoldenLayout:class).registerComponent} (deprecated)
+     * * {@link (GoldenLayout:class).registerComponentConstructor}
+     * * {@link (GoldenLayout:class).registerComponentFactoryFunction}
+     */
+    componentType: JsonValue;
+    /**
+     * The state information with which a component will be initialised with.
+     * Will be passed to the component constructor function and will be the value returned by
+     * container.initialState.
+     */
+    componentState?: JsonValue;
+    /**
+     * Default: true
+     */
+    reorderEnabled?: boolean;
+}
+
+/** @public */
+export declare namespace ComponentItemConfig {
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: fromResolved */
+    export function componentTypeToTitle(componentType: JsonValue): string;
+}
+
+declare abstract class ComponentParentableItem extends ContentItem {
+    /* Excluded from this release type: _focused */
+    get focused(): boolean;
+    /* Excluded from this release type: setFocusedValue */
+    abstract setActiveComponentItem(item: ComponentItem, focus: boolean, suppressFocusEvent: boolean): void;
+}
+
+/** @public @deprecated - use {@link (LayoutConfig:interface)} */
+export declare type Config = LayoutConfig;
+
+/** @public */
+export declare class ConfigurationError extends ExternalError {
+    readonly node?: string | undefined;
+    /* Excluded from this release type: __constructor */
+}
+
+/**
+ * This is the baseclass that all content items inherit from.
+ * Most methods provide a subset of what the sub-classes do.
+ *
+ * It also provides a number of functions for tree traversal
+ * @public
+ */
+export declare abstract class ContentItem extends EventEmitter {
+    readonly layoutManager: LayoutManager;
+    /* Excluded from this release type: _parent */
+    /* Excluded from this release type: _element */
+    /* Excluded from this release type: _type */
+    /* Excluded from this release type: _id */
+    /* Excluded from this release type: _popInParentIds */
+    /* Excluded from this release type: _contentItems */
+    /* Excluded from this release type: _isClosable */
+    /* Excluded from this release type: _pendingEventPropagations */
+    /* Excluded from this release type: _throttledEvents */
+    /* Excluded from this release type: _isInitialised */
+    /* Excluded from this release type: size */
+    /* Excluded from this release type: sizeUnit */
+    /* Excluded from this release type: minSize */
+    /* Excluded from this release type: minSizeUnit */
+    isGround: boolean;
+    isRow: boolean;
+    isColumn: boolean;
+    isStack: boolean;
+    isComponent: boolean;
+    get type(): ItemType;
+    get id(): string;
+    set id(value: string);
+    /* Excluded from this release type: popInParentIds */
+    get parent(): ContentItem | null;
+    get contentItems(): ContentItem[];
+    get isClosable(): boolean;
+    get element(): HTMLElement;
+    get isInitialised(): boolean;
+    static isStack(item: ContentItem): item is Stack;
+    static isComponentItem(item: ContentItem): item is ComponentItem;
+    static isComponentParentableItem(item: ContentItem): item is ComponentParentableItem;
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: updateSize */
+    /**
+     * Removes a child node (and its children) from the tree
+     * @param contentItem - The child item to remove
+     * @param keepChild - Whether to destroy the removed item
+     */
+    removeChild(contentItem: ContentItem, keepChild?: boolean): void;
+    /**
+     * Sets up the tree structure for the newly added child
+     * The responsibility for the actual DOM manipulations lies
+     * with the concrete item
+     *
+     * @param contentItem -
+     * @param index - If omitted item will be appended
+     * @param suspendResize - Used by descendent implementations
+     */
+    addChild(contentItem: ContentItem, index?: number | null, suspendResize?: boolean): number;
+    /* Excluded from this release type: replaceChild */
+    /**
+     * Convenience method.
+     * Shorthand for this.parent.removeChild( this )
+     */
+    remove(): void;
+    /**
+     * Removes the component from the layout and creates a new
+     * browser window with the component and its children inside
+     */
+    popout(): BrowserPopout;
+    abstract toConfig(): ResolvedItemConfig;
+    /* Excluded from this release type: calculateConfigContent */
+    /* Excluded from this release type: highlightDropZone */
+    /* Excluded from this release type: onDrop */
+    /* Excluded from this release type: show */
+    /* Excluded from this release type: destroy */
+    /* Excluded from this release type: getElementArea */
+    /* Excluded from this release type: init */
+    /* Excluded from this release type: setParent */
+    /* Excluded from this release type: addPopInParentId */
+    /* Excluded from this release type: initContentItems */
+    /* Excluded from this release type: hide */
+    /* Excluded from this release type: updateContentItemsSize */
+    /* Excluded from this release type: createContentItems */
+    /* Excluded from this release type: propagateEvent */
+    tryBubbleEvent(name: string, args: unknown[]): void;
+    /* Excluded from this release type: scheduleEventPropagationToLayoutManager */
+    /* Excluded from this release type: propagateEventToLayoutManager */
+}
+
+/** @public */
+export declare namespace ContentItem {
+    /* Excluded from this release type: Area */
+}
+
+/* Excluded from this release type: DragListener */
+
+/**
+ * Allows for any DOM item to create a component on drag
+ * start to be dragged into the Layout
+ * @public
+ */
+export declare class DragSource {
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _element */
+    /* Excluded from this release type: _extraAllowableChildTargets */
+    /* Excluded from this release type: _componentTypeOrFtn */
+    /* Excluded from this release type: _componentState */
+    /* Excluded from this release type: _title */
+    /* Excluded from this release type: _id */
+    /* Excluded from this release type: _dragListener */
+    /* Excluded from this release type: _dummyGroundContainer */
+    /* Excluded from this release type: _dummyGroundContentItem */
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: destroy */
+    /* Excluded from this release type: createDragListener */
+    /* Excluded from this release type: onDragStart */
+    /* Excluded from this release type: onDragStop */
+    /* Excluded from this release type: removeDragListener */
+}
+
+/** @public */
+export declare namespace DragSource {
+    /** @deprecated  use Config {@link (ComponentItemConfig:interface)} */
+    export interface ComponentItemConfig {
+        type: JsonValue;
+        state?: JsonValue;
+        title?: string;
+    }
+    /** @deprecated remove in version 3 */
+    export function isDragSourceComponentItemConfig(config: DragSource.ComponentItemConfig | ComponentItemConfig): config is DragSource.ComponentItemConfig;
+}
+
+/* Excluded from this release type: DropTargetIndicator */
+
+/**
+ * A generic and very fast EventEmitter implementation. On top of emitting the actual event it emits an
+ * {@link (EventEmitter:namespace).ALL_EVENT} event for every event triggered. This allows to hook into it and proxy events forwards
+ * @public
+ */
+export declare class EventEmitter {
+    /* Excluded from this release type: _allEventSubscriptions */
+    /* Excluded from this release type: _subscriptionsMap */
+    tryBubbleEvent(name: string, args: unknown[]): void;
+    /**
+     * Emit an event and notify listeners
+     *
+     * @param eventName - The name of the event
+     * @param args - Additional arguments that will be passed to the listener
+     */
+    emit<K extends keyof EventEmitter.EventParamsMap>(eventName: K, ...args: EventEmitter.EventParamsMap[K]): void;
+    /* Excluded from this release type: emitUnknown */
+    emitBaseBubblingEvent<K extends keyof EventEmitter.EventParamsMap>(eventName: K): void;
+    /* Excluded from this release type: emitUnknownBubblingEvent */
+    /**
+     * Removes a listener for an event.
+     * @param eventName - The name of the event
+     * @param callback - The previously registered callback method (optional)
+     */
+    removeEventListener<K extends keyof EventEmitter.EventParamsMap>(eventName: K, callback: EventEmitter.Callback<K>): void;
+    off<K extends keyof EventEmitter.EventParamsMap>(eventName: K, callback: EventEmitter.Callback<K>): void;
+    /**
+     * Alias for off
+     */
+    unbind: <K extends keyof EventEmitter.EventParamsMap>(eventName: K, callback: EventEmitter.Callback<K>) => void;
+    /**
+     * Alias for emit
+     */
+    trigger: <K extends keyof EventEmitter.EventParamsMap>(eventName: K, ...args: EventEmitter.EventParamsMap[K]) => void;
+    /**
+     * Listen for events
+     *
+     * @param eventName - The name of the event to listen to
+     * @param callback - The callback to execute when the event occurs
+     */
+    addEventListener<K extends keyof EventEmitter.EventParamsMap>(eventName: K, callback: EventEmitter.Callback<K>): void;
+    on<K extends keyof EventEmitter.EventParamsMap>(eventName: K, callback: EventEmitter.Callback<K>): void;
+    /* Excluded from this release type: addUnknownEventListener */
+    /* Excluded from this release type: removeUnknownEventListener */
+    /* Excluded from this release type: removeSubscription */
+    /* Excluded from this release type: emitAllEvent */
+}
+
+/** @public */
+export declare namespace EventEmitter {
+    /**
+     * The name of the event that's triggered for every event
+     */
+    const ALL_EVENT = "__all";
+    const headerClickEventName = "stackHeaderClick";
+    const headerTouchStartEventName = "stackHeaderTouchStart";
+    /* Excluded from this release type: UnknownCallback */
+    export type Callback<K extends keyof EventEmitter.EventParamsMap> = (this: void, ...args: EventParamsMap[K]) => void;
+    export interface EventParamsMap {
+        "__all": UnknownParams;
+        "activeContentItemChanged": ComponentItemParam;
+        "close": NoParams;
+        "closed": NoParams;
+        "destroy": NoParams;
+        "drag": DragParams;
+        "dragStart": DragStartParams;
+        "dragStop": DragStopParams;
+        "hide": NoParams;
+        "initialised": NoParams;
+        "itemDropped": ComponentItemParam;
+        "maximised": NoParams;
+        "minimised": NoParams;
+        "open": NoParams;
+        "popIn": NoParams;
+        "resize": NoParams;
+        "show": NoParams;
+        /** @deprecated - use show instead */
+        "shown": NoParams;
+        "stateChanged": NoParams;
+        "tab": TabParam;
+        "tabCreated": TabParam;
+        "titleChanged": StringParam;
+        "windowClosed": PopoutParam;
+        "windowOpened": PopoutParam;
+        "beforeComponentRelease": BeforeComponentReleaseParams;
+        "beforeItemDestroyed": BubblingEventParam;
+        "itemCreated": BubblingEventParam;
+        "itemDestroyed": BubblingEventParam;
+        "focus": BubblingEventParam;
+        "blur": BubblingEventParam;
+        "stackHeaderClick": ClickBubblingEventParam;
+        "stackHeaderTouchStart": TouchStartBubblingEventParam;
+        "userBroadcast": UnknownParams;
+    }
+    export type UnknownParams = unknown[];
+    export type NoParams = [];
+    export type UnknownParam = [unknown];
+    export type PopoutParam = [BrowserPopout];
+    export type ComponentItemParam = [ComponentItem];
+    export type TabParam = [Tab];
+    export type BubblingEventParam = [EventEmitter.BubblingEvent];
+    export type StringParam = [string];
+    export type DragStartParams = [originalX: number, originalY: number];
+    export type DragStopParams = [event: PointerEvent | undefined];
+    export type DragParams = [offsetX: number, offsetY: number, event: PointerEvent];
+    export type BeforeComponentReleaseParams = [component: unknown];
+    export type ClickBubblingEventParam = [ClickBubblingEvent];
+    export type TouchStartBubblingEventParam = [TouchStartBubblingEvent];
+    export class BubblingEvent {
+        /* Excluded from this release type: _name */
+        /* Excluded from this release type: _target */
+        /* Excluded from this release type: _isPropagationStopped */
+        get name(): string;
+        get target(): EventEmitter;
+        /** @deprecated Use {@link (EventEmitter:namespace).(BubblingEvent:class).target} instead */
+        get origin(): EventEmitter;
+        get isPropagationStopped(): boolean;
+        /* Excluded from this release type: __constructor */
+        stopPropagation(): void;
+    }
+    export class ClickBubblingEvent extends BubblingEvent {
+        /* Excluded from this release type: _mouseEvent */
+        get mouseEvent(): MouseEvent;
+        /* Excluded from this release type: __constructor */
+    }
+    export class TouchStartBubblingEvent extends BubblingEvent {
+        /* Excluded from this release type: _touchEvent */
+        get touchEvent(): TouchEvent;
+        /* Excluded from this release type: __constructor */
+    }
+}
+
+/**
+ * An EventEmitter singleton that propagates events
+ * across multiple windows. This is a little bit trickier since
+ * windows are allowed to open childWindows in their own right.
+ *
+ * This means that we deal with a tree of windows. Therefore, we do the event propagation in two phases:
+ *
+ * - Propagate events from this layout to the parent layout
+ *   - Repeat until the event arrived at the root layout
+ * - Propagate events to this layout and to all children
+ *   - Repeat until all layouts got the event
+ *
+ * **WARNING**: Only userBroadcast events are propagated between windows.
+ * This means the you have to take care of propagating state changes between windows yourself.
+ *
+ * @public
+ */
+export declare class EventHub extends EventEmitter {
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _childEventListener */
+    /* Excluded from this release type: __constructor */
+    /**
+     * Emit an event and notify listeners
+     *
+     * @param eventName - The name of the event
+     * @param args - Additional arguments that will be passed to the listener
+     * @public
+     */
+    emit<K extends keyof EventEmitter.EventParamsMap>(eventName: K, ...args: EventEmitter.EventParamsMap[K]): void;
+    /**
+     * Broadcasts a message to all other currently opened windows.
+     * @public
+     */
+    emitUserBroadcast(...args: EventEmitter.UnknownParams): void;
+    /* Excluded from this release type: destroy */
+    /* Excluded from this release type: handleUserBroadcastEvent */
+    /* Excluded from this release type: onEventFromChild */
+    /* Excluded from this release type: propagateToParent */
+    /* Excluded from this release type: propagateToThisAndSubtree */
+}
+
+/** @public */
+export declare namespace EventHub {
+    /* Excluded from this release type: ChildEventName */
+    /* Excluded from this release type: ChildEventDetail */
+    /* Excluded from this release type: ChildEventInit */
+}
+
+/** @public */
+export declare abstract class ExternalError extends Error {
+    readonly type: string;
+    /* Excluded from this release type: __constructor */
+}
+
+/* Excluded from this release type: formatSize */
+
+/* Excluded from this release type: formatUndefinableSize */
+
+/** @public */
+export declare class GoldenLayout extends VirtualLayout {
+    /* Excluded from this release type: _componentTypesMap */
+    /* Excluded from this release type: _getComponentConstructorFtn */
+    /* Excluded from this release type: _registeredComponentMap */
+    /* Excluded from this release type: _virtuableComponentMap */
+    /* Excluded from this release type: _goldenLayoutBoundingClientRect */
+    /* Excluded from this release type: _containerVirtualRectingRequiredEventListener */
+    /* Excluded from this release type: _containerVirtualVisibilityChangeRequiredEventListener */
+    /* Excluded from this release type: _containerVirtualZIndexChangeRequiredEventListener */
+    /**
+     * @param container - A Dom HTML element. Defaults to body
+     * @param bindComponentEventHandler - Event handler to bind components
+     * @param bindComponentEventHandler - Event handler to unbind components
+     * If bindComponentEventHandler is defined, then constructor will be determinate. It will always call the init()
+     * function and the init() function will always complete. This means that the bindComponentEventHandler will be called
+     * if constructor is for a popout window. Make sure bindComponentEventHandler is ready for events.
+     */
+    constructor(container?: HTMLElement, bindComponentEventHandler?: VirtualLayout.BindComponentEventHandler, unbindComponentEventHandler?: VirtualLayout.UnbindComponentEventHandler);
+    /** @deprecated specify layoutConfig in {@link (LayoutManager:class).loadLayout} */
+    constructor(config: LayoutConfig, container?: HTMLElement);
+    /**
+     * Register a new component type with the layout manager.
+     *
+     * @deprecated See {@link https://stackoverflow.com/questions/40922531/how-to-check-if-a-javascript-function-is-a-constructor}
+     * instead use {@link (GoldenLayout:class).registerComponentConstructor}
+     * or {@link (GoldenLayout:class).registerComponentFactoryFunction}
+     */
+    registerComponent(name: string, componentConstructorOrFactoryFtn: GoldenLayout.ComponentConstructor | GoldenLayout.ComponentFactoryFunction, virtual?: boolean): void;
+    /**
+     * Register a new component type with the layout manager.
+     */
+    registerComponentConstructor(typeName: string, componentConstructor: GoldenLayout.ComponentConstructor, virtual?: boolean): void;
+    /**
+     * Register a new component with the layout manager.
+     */
+    registerComponentFactoryFunction(typeName: string, componentFactoryFunction: GoldenLayout.ComponentFactoryFunction, virtual?: boolean): void;
+    /**
+     * Register a component function with the layout manager. This function should
+     * return a constructor for a component based on a config.
+     * This function will be called if a component type with the required name is not already registered.
+     * It is recommended that applications use the {@link (VirtualLayout:class).getComponentEvent} and
+     * {@link (VirtualLayout:class).releaseComponentEvent} instead of registering a constructor callback
+     * @deprecated use {@link (GoldenLayout:class).registerGetComponentConstructorCallback}
+     */
+    registerComponentFunction(callback: GoldenLayout.GetComponentConstructorCallback): void;
+    /**
+     * Register a callback closure with the layout manager which supplies a Component Constructor.
+     * This callback should return a constructor for a component based on a config.
+     * This function will be called if a component type with the required name is not already registered.
+     * It is recommended that applications use the {@link (VirtualLayout:class).getComponentEvent} and
+     * {@link (VirtualLayout:class).releaseComponentEvent} instead of registering a constructor callback
+     */
+    registerGetComponentConstructorCallback(callback: GoldenLayout.GetComponentConstructorCallback): void;
+    getRegisteredComponentTypeNames(): string[];
+    /**
+     * Returns a previously registered component instantiator.  Attempts to utilize registered
+     * component type by first, then falls back to the component constructor callback function (if registered).
+     * If neither gets an instantiator, then returns `undefined`.
+     * Note that `undefined` will return if config.componentType is not a string
+     *
+     * @param config - The item config
+     * @public
+     */
+    getComponentInstantiator(config: ResolvedComponentItemConfig): GoldenLayout.ComponentInstantiator | undefined;
+    /* Excluded from this release type: bindComponent */
+    /* Excluded from this release type: unbindComponent */
+    fireBeforeVirtualRectingEvent(count: number): void;
+    /* Excluded from this release type: handleContainerVirtualRectingRequiredEvent */
+    /* Excluded from this release type: handleContainerVirtualVisibilityChangeRequiredEvent */
+    /* Excluded from this release type: handleContainerVirtualZIndexChangeRequiredEvent */
+}
+
+/** @public */
+export declare namespace GoldenLayout {
+    export interface VirtuableComponent {
+        rootHtmlElement: HTMLElement;
+    }
+    export type ComponentConstructor = new (container: ComponentContainer, state: JsonValue | undefined, virtual: boolean) => ComponentContainer.Component;
+    export type ComponentFactoryFunction = (container: ComponentContainer, state: JsonValue | undefined, virtual: boolean) => ComponentContainer.Component | undefined;
+    export type GetComponentConstructorCallback = (this: void, config: ResolvedComponentItemConfig) => ComponentConstructor;
+    export interface ComponentInstantiator {
+        constructor: ComponentConstructor | undefined;
+        factoryFunction: ComponentFactoryFunction | undefined;
+        virtual: boolean;
+    }
+}
+
+/* Excluded from this release type: GroundItem */
+
+/**
+ * This class represents a header above a Stack ContentItem.
+ * @public
+ */
+export declare class Header extends EventEmitter {
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _parent */
+    /* Excluded from this release type: _configClosable */
+    /* Excluded from this release type: _getActiveComponentItemEvent */
+    /* Excluded from this release type: _popoutEvent */
+    /* Excluded from this release type: _maximiseToggleEvent */
+    /* Excluded from this release type: _clickEvent */
+    /* Excluded from this release type: _touchStartEvent */
+    /* Excluded from this release type: _componentRemoveEvent */
+    /* Excluded from this release type: _componentFocusEvent */
+    /* Excluded from this release type: _componentDragStartEvent */
+    /* Excluded from this release type: _tabsContainer */
+    /* Excluded from this release type: _element */
+    /* Excluded from this release type: _controlsContainerElement */
+    /* Excluded from this release type: _show */
+    /* Excluded from this release type: _popoutEnabled */
+    /* Excluded from this release type: _popoutLabel */
+    /* Excluded from this release type: _maximiseEnabled */
+    /* Excluded from this release type: _maximiseLabel */
+    /* Excluded from this release type: _minimiseEnabled */
+    /* Excluded from this release type: _minimiseLabel */
+    /* Excluded from this release type: _closeEnabled */
+    /* Excluded from this release type: _closeLabel */
+    /* Excluded from this release type: _tabDropdownEnabled */
+    /* Excluded from this release type: _tabDropdownLabel */
+    /* Excluded from this release type: _tabControlOffset */
+    /* Excluded from this release type: _clickListener */
+    /* Excluded from this release type: _touchStartListener */
+    /* Excluded from this release type: _documentMouseUpListener */
+    /* Excluded from this release type: _rowColumnClosable */
+    /* Excluded from this release type: _canRemoveComponent */
+    /* Excluded from this release type: _side */
+    /* Excluded from this release type: _leftRightSided */
+    /* Excluded from this release type: _closeButton */
+    /* Excluded from this release type: _popoutButton */
+    /* Excluded from this release type: _tabDropdownButton */
+    /* Excluded from this release type: _maximiseButton */
+    get show(): boolean;
+    get side(): Side;
+    get leftRightSided(): boolean;
+    get layoutManager(): LayoutManager;
+    get parent(): Stack;
+    get tabs(): Tab[];
+    get lastVisibleTabIndex(): number;
+    get element(): HTMLElement;
+    get tabsContainerElement(): HTMLElement;
+    get controlsContainerElement(): HTMLElement;
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: destroy */
+    /* Excluded from this release type: createTab */
+    /* Excluded from this release type: removeTab */
+    /* Excluded from this release type: processActiveComponentChanged */
+    /* Excluded from this release type: setSide */
+    /* Excluded from this release type: setRowColumnClosable */
+    /* Excluded from this release type: updateClosability */
+    /* Excluded from this release type: applyFocusedValue */
+    /* Excluded from this release type: processMaximised */
+    /* Excluded from this release type: processMinimised */
+    /* Excluded from this release type: updateTabSizes */
+    /* Excluded from this release type: handleTabInitiatedComponentRemoveEvent */
+    /* Excluded from this release type: handleTabInitiatedComponentFocusEvent */
+    /* Excluded from this release type: handleTabInitiatedDragStartEvent */
+    /* Excluded from this release type: processTabDropdownActiveChanged */
+    /* Excluded from this release type: handleButtonPopoutEvent */
+    /* Excluded from this release type: handleButtonMaximiseToggleEvent */
+    /* Excluded from this release type: onClick */
+    /* Excluded from this release type: onTouchStart */
+    /* Excluded from this release type: notifyClick */
+    /* Excluded from this release type: notifyTouchStart */
+}
+
+/** @public */
+export declare namespace Header {
+    /* Excluded from this release type: GetActiveComponentItemEvent */
+    /* Excluded from this release type: CloseEvent */
+    /* Excluded from this release type: PopoutEvent */
+    /* Excluded from this release type: MaximiseToggleEvent */
+    /* Excluded from this release type: ClickEvent */
+    /* Excluded from this release type: TouchStartEvent */
+    /* Excluded from this release type: ComponentRemoveEvent */
+    /* Excluded from this release type: ComponentFocusEvent */
+    /* Excluded from this release type: ComponentDragStartEvent */
+    /* Excluded from this release type: StateChangedEvent */
+    /* Excluded from this release type: Settings */
+}
+
+/** @public */
+export declare interface HeaderedItemConfig extends ItemConfig {
+    /** @deprecated use {@link (HeaderedItemConfig:namespace).(Header:interface).show} instead */
+    hasHeaders?: boolean;
+    header?: HeaderedItemConfig.Header;
+    maximised?: boolean;
+}
+
+/** @public */
+export declare namespace HeaderedItemConfig {
+    export interface Header {
+        show?: false | Side;
+        popout?: false | string;
+        dock?: false | string;
+        maximise?: false | string;
+        close?: string;
+        minimise?: string;
+        tabDropdown?: false | string;
+    }
+    export namespace Header {
+        export function resolve(header: Header | undefined, hasHeaders: boolean | undefined): ResolvedHeaderedItemConfig.Header | undefined;
+    }
+    /* Excluded from this release type: resolveIdAndMaximised */
+}
+
+/** @public */
+export declare const enum I18nStringId {
+    PopoutCannotBeCreatedWithGroundItemConfig = 0,
+    PleaseRegisterAConstructorFunction = 1,
+    ComponentTypeNotRegisteredAndBindComponentEventHandlerNotAssigned = 2,
+    ComponentIsAlreadyRegistered = 3,
+    ComponentIsNotVirtuable = 4,
+    VirtualComponentDoesNotHaveRootHtmlElement = 5,
+    ItemConfigIsNotTypeComponent = 6,
+    InvalidNumberPartInSizeString = 7,
+    UnknownUnitInSizeString = 8,
+    UnsupportedUnitInSizeString = 9
+}
+
+/** @public */
+export declare namespace I18nStrings {
+    const idCount: number;
+    export function checkInitialise(): void;
+}
+
+/** @public */
+export declare const i18nStrings: string[];
+
+/** @public */
+export declare interface ItemConfig {
+    /**
+     * The type of the item. Possible values are 'row', 'column', 'stack', 'component'.
+     */
+    type: ItemType;
+    /**
+     * An array of configurations for items that will be created as children of this item.
+     */
+    content?: ItemConfig[];
+    /**
+     * The width of this item, relative to the other children of its parent in percent
+     * @deprecated use {@link (ItemConfig:interface).size} instead
+     */
+    width?: number;
+    /**
+     * The minimum width of this item in pixels
+     * CAUTION - Not tested - do not use
+     * @deprecated use {@link (ItemConfig:interface).minSize} instead
+     */
+    minWidth?: number;
+    /**
+     * The height of this item, relative to the other children of its parent in percent
+     * @deprecated use {@link (ItemConfig:interface).size} instead
+     */
+    height?: number;
+    /**
+     * The minimum height of this item in pixels
+     * CAUTION - Not tested - do not use
+     * @deprecated use {@link (ItemConfig:interface).minSize} instead
+     */
+    minHeight?: number;
+    /**
+     * The size of this item.
+     * For rows, it specifies height. For columns, it specifies width.
+     * Has format \<number\>\<{@link SizeUnit}\>. Currently only supports units `fr` and `%`.
+     *
+     * Space is first proportionally allocated to items with sizeUnit `%`.
+     * If there is any space left over (less than 100% allocated), then the
+     * remainder is allocated to the items with unit `fr` according to the fractional size.
+     * If more than 100% is allocated, then an extra 50% is allocated to items with unit `fr` and
+     * is allocated to each item according to its fractional size. All item sizes are then adjusted
+     * to bring the total back to 100%
+     */
+    size?: string;
+    /**
+     * The size of this item.
+     * For rows, it specifies height. For columns, it specifies width.
+     * Has format <number><sizeUnit>. Currently only supports units `px`
+     */
+    minSize?: string;
+    /**
+     * A string that can be used to identify a ContentItem.
+     * Do NOT assign an array.  This only exists for legacy purposes.  If an array is assigned, the first element
+     * will become the id.
+     */
+    id?: 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: componentType.toString() or ''
+     * @deprecated only Component has a title
+     */
+    title?: string;
+}
+
+/** @public */
+export declare namespace ItemConfig {
+    /* Excluded from this release type: SizeWidthHeightSpecificationType */
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: resolveContent */
+    /* Excluded from this release type: resolveId */
+    /* Excluded from this release type: resolveSize */
+    /* Excluded from this release type: resolveMinSize */
+    /* Excluded from this release type: calculateSizeWidthHeightSpecificationType */
+    export function isGround(config: ItemConfig): config is ItemConfig;
+    export function isRow(config: ItemConfig): config is ItemConfig;
+    export function isColumn(config: ItemConfig): config is ItemConfig;
+    export function isStack(config: ItemConfig): config is ItemConfig;
+    export function isComponent(config: ItemConfig): config is ComponentItemConfig;
+}
+
+/** @public */
+export declare type ItemType = 'ground' | 'row' | 'column' | 'stack' | 'component';
+
+/** @public */
+export declare namespace ItemType {
+    const ground = "ground";
+    const row = "row";
+    const column = "column";
+    const stack = "stack";
+    const component = "component";
+}
+
+/** @public */
+export declare interface Json {
+    [name: string]: JsonValue;
+}
+
+/** @public */
+export declare type JsonValue = string | number | boolean | null | Json | object | JsonValueArray;
+
+/** @public */
+export declare namespace JsonValue {
+    export function isJson(value: JsonValue): value is Json;
+    export function isJsonObject(value: JsonValue): value is Json | object;
+}
+
+/** @public */
+export declare type JsonValueArray = Array<JsonValue>;
+
+/** @public */
+export declare interface LayoutConfig {
+    root: RootItemConfig | undefined;
+    /** @deprecated Use {@link (LayoutConfig:interface).root} */
+    content?: (RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig)[];
+    openPopouts?: PopoutLayoutConfig[];
+    dimensions?: LayoutConfig.Dimensions;
+    settings?: LayoutConfig.Settings;
+    /** @deprecated use {@link (LayoutConfig:interface).header} instead */
+    labels?: LayoutConfig.Labels;
+    header?: LayoutConfig.Header;
+}
+
+/** Use to specify LayoutConfig with defaults or deserialise a LayoutConfig.
+ * Deserialisation will handle backwards compatibility.
+ * Note that LayoutConfig should be used for serialisation (not LayoutConfig)
+ * @public
+ */
+export declare namespace LayoutConfig {
+    export interface Settings {
+        /**
+         * @deprecated use ${@link (LayoutConfig:namespace).(Header:interface).show} instead
+         */
+        hasHeaders?: boolean;
+        /**
+         * 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.
+         * Can be overridden by ItemConfig.reorderEnabled for specific ItemConfigs
+         * Default: true
+         */
+        reorderEnabled?: 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
+         * @deprecated Will be removed in version 3.
+         */
+        closePopoutsOnUnload?: boolean;
+        /**
+         * Specifies if the popout icon should be displayed in the header-bar.
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).popout} instead
+         */
+        showPopoutIcon?: boolean;
+        /**
+         * Specifies if the maximise icon should be displayed in the header-bar.
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).maximise} instead
+         */
+        showMaximiseIcon?: boolean;
+        /**
+         * Specifies if the close icon should be displayed in the header-bar.
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).close} instead
+         */
+        showCloseIcon?: boolean;
+        /**
+         * Specifies Responsive Mode (more info needed).
+         * Default: none
+         */
+        responsiveMode?: ResponsiveMode;
+        /**
+         * Specifies Maximum pixel overlap per tab.
+         * Default: 0
+         */
+        tabOverlapAllowance?: number;
+        /**
+         *
+         * Default: true
+         */
+        reorderOnTabMenuClick?: boolean;
+        /**
+         * Default: 10
+         */
+        tabControlOffset?: number;
+        /**
+         * Specifies whether to pop in elements when closing a popout window.
+         * Default: false
+         */
+        popInOnClose?: boolean;
+    }
+    export namespace Settings {
+        export function resolve(settings: Settings | undefined): ResolvedLayoutConfig.Settings;
+    }
+    export 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;
+        /**
+         * Default: 15
+         */
+        borderGrabWidth?: number;
+        /**
+         * The minimum height an item can be resized to (in pixel).
+         * @deprecated use {@link (LayoutConfig:namespace).(Dimensions:interface).defaultMinItemHeight} instead
+         */
+        minItemHeight?: number;
+        /**
+         * The minimum height an item can be resized to.
+         * Default: 0
+         */
+        defaultMinItemHeight?: string;
+        /**
+         * The minimum width an item can be resized to (in pixel).
+         * @deprecated use {@link (LayoutConfig:namespace).(Dimensions:interface).defaultMinItemWidth} instead
+         */
+        minItemWidth?: number;
+        /**
+         * The minimum width an item can be resized to.
+         * Default: 10px
+         */
+        defaultMinItemWidth?: string;
+        /**
+         * 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;
+    }
+    export namespace Dimensions {
+        /* Excluded from this release type: resolve */
+        /* Excluded from this release type: fromResolved */
+        /* Excluded from this release type: resolveDefaultMinItemHeight */
+        /* Excluded from this release type: resolveDefaultMinItemWidth */
+    }
+    export interface Labels {
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).close} instead
+         */
+        close?: string;
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).maximise} instead
+         */
+        maximise?: string;
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).minimise} instead
+         */
+        minimise?: string;
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).popin} instead
+         */
+        popin?: string;
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).popout} instead
+         */
+        popout?: string;
+        /**
+         * @deprecated use {@link (LayoutConfig:namespace).(Header:interface).tabDropdown} instead
+         */
+        tabDropdown?: string;
+    }
+    export interface Header {
+        /**
+         * Specifies whether header should be displayed, and if so, on which side.
+         * If false, the layout will be displayed with splitters only.
+         * Default: 'top'
+         */
+        show?: false | Side;
+        /**
+         * The tooltip text that appears when hovering over the popout icon or false if popout button not displayed.
+         * Default: 'open in new window'
+         */
+        popout?: false | string;
+        /**
+         * The tooltip text that appears when hovering over the popin icon.
+         * Default: 'pop in'
+         */
+        popin?: string;
+        /**
+         * The tooltip text that appears when hovering over the maximise icon or false if maximised button not displayed.
+         * Default: 'maximise'
+         */
+        maximise?: false | string;
+        /**
+         * The tooltip text that appears when hovering over the close icon.
+         * Default: 'close'
+         */
+        close?: false | string;
+        /**
+         * The tooltip text that appears when hovering over the minimise icon.
+         * Default: 'minimise'
+         */
+        minimise?: string;
+        /**
+         *
+         * Default: 'additional tabs'
+         */
+        tabDropdown?: false | string;
+    }
+    export namespace Header {
+        /* Excluded from this release type: resolve */
+    }
+    export function isPopout(config: LayoutConfig): config is PopoutLayoutConfig;
+    /* Excluded from this release type: resolve */
+    export function fromResolved(config: ResolvedLayoutConfig): LayoutConfig;
+    export function isResolved(configOrResolvedConfig: ResolvedLayoutConfig | LayoutConfig): configOrResolvedConfig is ResolvedLayoutConfig;
+    /* Excluded from this release type: resolveOpenPopouts */
+}
+
+/**
+ * The main class that will be exposed as GoldenLayout.
+ */
+/** @public */
+export declare abstract class LayoutManager extends EventEmitter {
+    /** Whether the layout will be automatically be resized to container whenever the container's size is changed
+     * Default is true if <body> is the container otherwise false
+     * Default will be changed to true for any container in the future
+     */
+    resizeWithContainerAutomatically: boolean;
+    /** The debounce interval (in milliseconds) used whenever a layout is automatically resized.  0 means next tick */
+    resizeDebounceInterval: number;
+    /** Extend the current debounce delay time period if it is triggered during the delay.
+     * If this is true, the layout will only resize when its container has stopped being resized.
+     * If it is false, the layout will resize at intervals while its container is being resized.
+     */
+    resizeDebounceExtendedWhenPossible: boolean;
+    /* Excluded from this release type: _containerElement */
+    /* Excluded from this release type: _isInitialised */
+    /* Excluded from this release type: _groundItem */
+    /* Excluded from this release type: _openPopouts */
+    /* Excluded from this release type: _dropTargetIndicator */
+    /* Excluded from this release type: _transitionIndicator */
+    /* Excluded from this release type: _resizeTimeoutId */
+    /* Excluded from this release type: _itemAreas */
+    /* Excluded from this release type: _maximisedStack */
+    /* Excluded from this release type: _maximisePlaceholder */
+    /* Excluded from this release type: _tabDropPlaceholder */
+    /* Excluded from this release type: _dragSources */
+    /* Excluded from this release type: _updatingColumnsResponsive */
+    /* Excluded from this release type: _firstLoad */
+    /* Excluded from this release type: _eventHub */
+    /* Excluded from this release type: _width */
+    /* Excluded from this release type: _height */
+    /* Excluded from this release type: _focusedComponentItem */
+    /* Excluded from this release type: _virtualSizedContainers */
+    /* Excluded from this release type: _virtualSizedContainerAddingBeginCount */
+    /* Excluded from this release type: _sizeInvalidationBeginCount */
+    /* Excluded from this release type: _constructorOrSubWindowLayoutConfig */
+    /* Excluded from this release type: _resizeObserver */
+    /* Excluded from this release type: _windowBeforeUnloadListener */
+    /* Excluded from this release type: _windowBeforeUnloadListening */
+    /* Excluded from this release type: _maximisedStackBeforeDestroyedListener */
+    readonly isSubWindow: boolean;
+    layoutConfig: ResolvedLayoutConfig;
+    beforeVirtualRectingEvent: LayoutManager.BeforeVirtualRectingEvent | undefined;
+    afterVirtualRectingEvent: LayoutManager.AfterVirtualRectingEvent | undefined;
+    get container(): HTMLElement;
+    get isInitialised(): boolean;
+    /* Excluded from this release type: groundItem */
+    /* Excluded from this release type: root */
+    get openPopouts(): BrowserPopout[];
+    /* Excluded from this release type: dropTargetIndicator */
+    /* Excluded from this release type: transitionIndicator */
+    get width(): number | null;
+    get height(): number | null;
+    /**
+     * Retrieves the {@link (EventHub:class)} instance associated with this layout manager.
+     * This can be used to propagate events between the windows
+     * @public
+     */
+    get eventHub(): EventHub;
+    get rootItem(): ContentItem | undefined;
+    get focusedComponentItem(): ComponentItem | undefined;
+    /* Excluded from this release type: tabDropPlaceholder */
+    get maximisedStack(): Stack | undefined;
+    /** @deprecated indicates deprecated constructor use */
+    get deprecatedConstructor(): boolean;
+    /* Excluded from this release type: __constructor */
+    /**
+     * Destroys the LayoutManager instance itself as well as every ContentItem
+     * within it. After this is called nothing should be left of the LayoutManager.
+     *
+     * This function only needs to be called if an application wishes to destroy the Golden Layout object while
+     * a page remains loaded. When a page is unloaded, all resources claimed by Golden Layout will automatically
+     * be released.
+     */
+    destroy(): void;
+    /**
+     * Takes a GoldenLayout configuration object and
+     * replaces its keys and values recursively with
+     * one letter codes
+     * @deprecated use {@link (ResolvedLayoutConfig:namespace).minifyConfig} instead
+     */
+    minifyConfig(config: ResolvedLayoutConfig): ResolvedLayoutConfig;
+    /**
+     * Takes a configuration Object that was previously minified
+     * using minifyConfig and returns its original version
+     * @deprecated use {@link (ResolvedLayoutConfig:namespace).unminifyConfig} instead
+     */
+    unminifyConfig(config: ResolvedLayoutConfig): ResolvedLayoutConfig;
+    /* Excluded from this release type: bindComponent */
+    /* Excluded from this release type: unbindComponent */
+    /* Excluded from this release type: init */
+    /**
+     * Loads a new layout
+     * @param layoutConfig - New layout to be loaded
+     */
+    loadLayout(layoutConfig: LayoutConfig): void;
+    /**
+     * Creates a layout configuration object based on the the current state
+     *
+     * @public
+     * @returns GoldenLayout configuration
+     */
+    saveLayout(): ResolvedLayoutConfig;
+    /**
+     * Removes any existing layout. Effectively, an empty layout will be loaded.
+     */
+    clear(): void;
+    /**
+     * @deprecated Use {@link (LayoutManager:class).saveLayout}
+     */
+    toConfig(): ResolvedLayoutConfig;
+    /**
+     * Adds a new ComponentItem.  Will use default location selectors to ensure a location is found and
+     * component is successfully added
+     * @param componentTypeName - Name of component type to be created.
+     * @param state - Optional initial state to be assigned to component
+     * @returns New ComponentItem created.
+     */
+    newComponent(componentType: JsonValue, componentState?: JsonValue, title?: string): ComponentItem;
+    /**
+     * Adds a ComponentItem at the first valid selector location.
+     * @param componentTypeName - Name of component type to be created.
+     * @param state - Optional initial state to be assigned to component
+     * @param locationSelectors - Array of location selectors used to find location in layout where component
+     * will be added. First location in array which is valid will be used. If locationSelectors is undefined,
+     * {@link (LayoutManager:namespace).defaultLocationSelectors} will be used
+     * @returns New ComponentItem created or undefined if no valid location selector was in array.
+     */
+    newComponentAtLocation(componentType: JsonValue, componentState?: JsonValue, title?: string, locationSelectors?: LayoutManager.LocationSelector[]): ComponentItem | undefined;
+    /**
+     * Adds a new ComponentItem.  Will use default location selectors to ensure a location is found and
+     * component is successfully added
+     * @param componentType - Type of component to be created.
+     * @param state - Optional initial state to be assigned to component
+     * @returns Location of new ComponentItem created.
+     */
+    addComponent(componentType: JsonValue, componentState?: JsonValue, title?: string): LayoutManager.Location;
+    /**
+     * Adds a ComponentItem at the first valid selector location.
+     * @param componentType - Type of component to be created.
+     * @param state - Optional initial state to be assigned to component
+     * @param locationSelectors - Array of location selectors used to find determine location in layout where component
+     * will be added. First location in array which is valid will be used. If undefined,
+     * {@link (LayoutManager:namespace).defaultLocationSelectors} will be used.
+     * @returns Location of new ComponentItem created or undefined if no valid location selector was in array.
+     */
+    addComponentAtLocation(componentType: JsonValue, componentState?: JsonValue, title?: string, locationSelectors?: readonly LayoutManager.LocationSelector[]): LayoutManager.Location | undefined;
+    /**
+     * Adds a new ContentItem.  Will use default location selectors to ensure a location is found and
+     * component is successfully added
+     * @param itemConfig - ResolvedItemConfig of child to be added.
+     * @returns New ContentItem created.
+     */
+    newItem(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig): ContentItem;
+    /**
+     * Adds a new child ContentItem under the root ContentItem.  If a root does not exist, then create root ContentItem instead
+     * @param itemConfig - ResolvedItemConfig of child to be added.
+     * @param locationSelectors - Array of location selectors used to find determine location in layout where ContentItem
+     * will be added. First location in array which is valid will be used. If undefined,
+     * {@link (LayoutManager:namespace).defaultLocationSelectors} will be used.
+     * @returns New ContentItem created or undefined if no valid location selector was in array. */
+    newItemAtLocation(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig, locationSelectors?: readonly LayoutManager.LocationSelector[]): ContentItem | undefined;
+    /**
+     * Adds a new ContentItem.  Will use default location selectors to ensure a location is found and
+     * component is successfully added.
+     * @param itemConfig - ResolvedItemConfig of child to be added.
+     * @returns Location of new ContentItem created. */
+    addItem(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig): LayoutManager.Location;
+    /**
+     * Adds a ContentItem at the first valid selector location.
+     * @param itemConfig - ResolvedItemConfig of child to be added.
+     * @param locationSelectors - Array of location selectors used to find determine location in layout where ContentItem
+     * will be added. First location in array which is valid will be used. If undefined,
+     * {@link (LayoutManager:namespace).defaultLocationSelectors} will be used.
+     * @returns Location of new ContentItem created or undefined if no valid location selector was in array. */
+    addItemAtLocation(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig, locationSelectors?: readonly LayoutManager.LocationSelector[]): LayoutManager.Location | undefined;
+    /** Loads the specified component ResolvedItemConfig as root.
+     * This can be used to display a Component all by itself.  The layout cannot be changed other than having another new layout loaded.
+     * Note that, if this layout is saved and reloaded, it will reload with the Component as a child of a Stack.
+     */
+    loadComponentAsRoot(itemConfig: ComponentItemConfig): void;
+    /** @deprecated Use {@link (LayoutManager:class).setSize} */
+    updateSize(width: number, height: number): void;
+    /**
+     * Updates the layout managers size
+     *
+     * @param width - Width in pixels
+     * @param height - Height in pixels
+     */
+    setSize(width: number, height: number): void;
+    /* Excluded from this release type: beginSizeInvalidation */
+    /* Excluded from this release type: endSizeInvalidation */
+    /* Excluded from this release type: updateSizeFromContainer */
+    /**
+     * Update the size of the root ContentItem.  This will update the size of all contentItems in the tree
+     * @param force - In some cases the size is not updated if it has not changed. In this case, events
+     * (such as ComponentContainer.virtualRectingRequiredEvent) are not fired. Setting force to true, ensures the size is updated regardless, and
+     * the respective events are fired. This is sometimes necessary when a component's size has not changed but it has become visible, and the
+     * relevant events need to be fired.
+     */
+    updateRootSize(force?: boolean): void;
+    /** @public */
+    createAndInitContentItem(config: ResolvedItemConfig, parent: ContentItem): ContentItem;
+    /* Excluded from this release type: createContentItem */
+    findFirstComponentItemById(id: string): ComponentItem | undefined;
+    /**
+     * Creates a popout window with the specified content at the specified position
+     *
+     * @param itemConfigOrContentItem - The content of the popout window's layout manager derived from either
+     * a {@link (ContentItem:class)} or {@link (ItemConfig:interface)} or ResolvedItemConfig content (array of {@link (ItemConfig:interface)})
+     * @param positionAndSize - The width, height, left and top of Popout window
+     * @param parentId -The id of the element this item will be appended to when popIn is called
+     * @param indexInParent - The position of this item within its parent element
+     */
+    createPopout(itemConfigOrContentItem: ContentItem | ResolvedRootItemConfig, positionAndSize: ResolvedPopoutLayoutConfig.Window, parentId: string | null, indexInParent: number | null): BrowserPopout;
+    /* Excluded from this release type: createPopoutFromContentItem */
+    /* Excluded from this release type: beginVirtualSizedContainerAdding */
+    /* Excluded from this release type: addVirtualSizedContainer */
+    /* Excluded from this release type: endVirtualSizedContainerAdding */
+    /* Excluded from this release type: fireBeforeVirtualRectingEvent */
+    /* Excluded from this release type: fireAfterVirtualRectingEvent */
+    /* Excluded from this release type: createPopoutFromItemConfig */
+    /* Excluded from this release type: createPopoutFromPopoutLayoutConfig */
+    /**
+     * Closes all Open Popouts
+     * Applications can call this method when a page is unloaded to remove its open popouts
+     */
+    closeAllOpenPopouts(): void;
+    /**
+     * Attaches DragListener to any given DOM element
+     * and turns it into a way of creating new ComponentItems
+     * by 'dragging' the DOM element into the layout
+     *
+     * @param element - The HTML element which will be listened to for commencement of drag.
+     * @param componentTypeOrItemConfigCallback - Type of component to be created, or a callback which will provide the ItemConfig
+     * to be used to create the component.
+     * @param componentState - Optional initial state of component.  This will be ignored if componentTypeOrFtn is a function.
+     *
+     * @returns an opaque object that identifies the DOM element
+     *          and the attached itemConfig. This can be used in
+     *          removeDragSource() later to get rid of the drag listeners.
+     */
+    newDragSource(element: HTMLElement, itemConfigCallback: () => (DragSource.ComponentItemConfig | ComponentItemConfig)): DragSource;
+    /** @deprecated will be replaced in version 3 with newDragSource(element: HTMLElement, itemConfig: ComponentItemConfig) */
+    newDragSource(element: HTMLElement, componentType: JsonValue, componentState?: JsonValue, title?: JsonValue, id?: string): DragSource;
+    /**
+     * Removes a DragListener added by createDragSource() so the corresponding
+     * DOM element is not a drag source any more.
+     */
+    removeDragSource(dragSource: DragSource): void;
+    /* Excluded from this release type: startComponentDrag */
+    /**
+     * Programmatically focuses an item. This focuses the specified component item
+     * and the item emits a focus event
+     *
+     * @param item - The component item to be focused
+     * @param suppressEvent - Whether to emit focus event
+     */
+    focusComponent(item: ComponentItem, suppressEvent?: boolean): void;
+    /**
+     * Programmatically blurs (defocuses) the currently focused component.
+     * If a component item is focused, then it is blurred and and the item emits a blur event
+     *
+     * @param item - The component item to be blurred
+     * @param suppressEvent - Whether to emit blur event
+     */
+    clearComponentFocus(suppressEvent?: boolean): void;
+    /* Excluded from this release type: setFocusedComponentItem */
+    /* Excluded from this release type: createContentItemFromConfig */
+    /* Excluded from this release type: setMaximisedStack */
+    checkMinimiseMaximisedStack(): void;
+    /* Excluded from this release type: cleanupBeforeMaximisedStackDestroyed */
+    /* Excluded from this release type: closeWindow */
+    /* Excluded from this release type: getArea */
+    /* Excluded from this release type: calculateItemAreas */
+    /* Excluded from this release type: checkLoadedLayoutMaximiseItem */
+    /* Excluded from this release type: processMaximiseStack */
+    /* Excluded from this release type: processMinimiseMaximisedStack */
+    /* Excluded from this release type: reconcilePopoutWindows */
+    /* Excluded from this release type: getAllContentItems */
+    /* Excluded from this release type: createSubWindows */
+    /* Excluded from this release type: handleContainerResize */
+    /* Excluded from this release type: processResizeWithDebounce */
+    private checkClearResizeTimeout;
+    /* Excluded from this release type: setContainer */
+    /* Excluded from this release type: onBeforeUnload */
+    /* Excluded from this release type: adjustColumnsResponsive */
+    /* Excluded from this release type: useResponsiveLayout */
+    /* Excluded from this release type: addChildContentItemsToContainer */
+    /* Excluded from this release type: getAllStacks */
+    /* Excluded from this release type: findFirstContentItemType */
+    /* Excluded from this release type: findFirstContentItemTypeRecursive */
+    /* Excluded from this release type: findFirstContentItemTypeByIdRecursive */
+    /* Excluded from this release type: findAllStacksRecursive */
+    /* Excluded from this release type: findFirstLocation */
+    /* Excluded from this release type: findLocation */
+    /* Excluded from this release type: tryCreateLocationFromParentItem */
+}
+
+/** @public */
+export declare namespace LayoutManager {
+    export type BeforeVirtualRectingEvent = (this: void, count: number) => void;
+    export type AfterVirtualRectingEvent = (this: void) => void;
+    /* Excluded from this release type: ConstructorParameters */
+    /* Excluded from this release type: createMaximisePlaceElement */
+    /* Excluded from this release type: createTabDropPlaceholderElement */
+    /**
+     * Specifies a location of a ContentItem without referencing the content item.
+     * Used to specify where a new item is to be added
+     * @public
+     */
+    export interface Location {
+        parentItem: ContentItem;
+        index: number;
+    }
+    /**
+     * A selector used to specify a unique location in the layout
+     * @public
+     */
+    export interface LocationSelector {
+        /** Specifies selector algorithm */
+        typeId: LocationSelector.TypeId;
+        /** Used by algorithm to determine index in found ContentItem */
+        index?: number;
+    }
+    /** @public */
+    export namespace LocationSelector {
+        export const enum TypeId {
+            /** Stack with focused Item. Index specifies offset from index of focused item (eg 1 is the position after focused item) */
+            FocusedItem = 0,
+            /** Stack with focused Item. Index specfies ContentItems index */
+            FocusedStack = 1,
+            /** First stack found in layout */
+            FirstStack = 2,
+            /** First Row or Column found in layout (rows are searched first) */
+            FirstRowOrColumn = 3,
+            /** First Row in layout */
+            FirstRow = 4,
+            /** First Column in layout */
+            FirstColumn = 5,
+            /** Finds a location if layout is empty. The found location will be the root ContentItem. */
+            Empty = 6,
+            /** Finds root if layout is empty, otherwise a child under root */
+            Root = 7
+        }
+    }
+    /**
+     * Default LocationSelectors array used if none is specified.  Will always find a location.
+     * @public
+     */
+    const defaultLocationSelectors: readonly LocationSelector[];
+    /**
+     * LocationSelectors to try to get location next to existing focused item
+     * @public
+     */
+    const afterFocusedItemIfPossibleLocationSelectors: readonly LocationSelector[];
+}
+
+/* Excluded from this release type: LeftAndTop */
+
+/** @public */
+export declare type LogicalZIndex = 'base' | 'drag' | 'stackMaximised';
+
+/** @public */
+export declare namespace LogicalZIndex {
+    const base = "base";
+    const drag = "drag";
+    const stackMaximised = "stackMaximised";
+}
+
+/** @public */
+export declare const LogicalZIndexToDefaultMap: {
+    base: string;
+    drag: string;
+    stackMaximised: string;
+};
+
+/* Excluded from this release type: parseSize */
+
+/** @public */
+export declare class PopoutBlockedError extends ExternalError {
+    /* Excluded from this release type: __constructor */
+}
+
+/** @public */
+export declare interface PopoutLayoutConfig extends LayoutConfig {
+    /** The id of the element the item will be appended to on popIn
+     * If null, append to topmost layout element
+     */
+    parentId: string | null | undefined;
+    /** The position of this element within its parent
+     * If null, position is last
+     */
+    indexInParent: number | null | undefined;
+    /** @deprecated use {@link (PopoutLayoutConfig:interface).window} */
+    dimensions: PopoutLayoutConfig.Dimensions | undefined;
+    window: PopoutLayoutConfig.Window | undefined;
+}
+
+/** @public */
+export declare namespace PopoutLayoutConfig {
+    /** @deprecated use {@link (PopoutLayoutConfig:namespace).(Window:interface)} */
+    export interface Dimensions extends LayoutConfig.Dimensions {
+        /** @deprecated use {@link (PopoutLayoutConfig:namespace).(Window:interface).width} */
+        width?: number | null;
+        /** @deprecated use {@link (PopoutLayoutConfig:namespace).(Window:interface).height} */
+        height?: number | null;
+        /** @deprecated use {@link (PopoutLayoutConfig:namespace).(Window:interface).left} */
+        left?: number | null;
+        /** @deprecated use {@link (PopoutLayoutConfig:namespace).(Window:interface).top} */
+        top?: number | null;
+    }
+    export interface Window {
+        width?: number;
+        height?: number;
+        left?: number;
+        top?: number;
+    }
+    export namespace Window {
+        /* Excluded from this release type: resolve */
+        /* Excluded from this release type: fromResolved */
+    }
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: fromResolved */
+    /* Excluded from this release type: fromResolvedArray */
+}
+
+/* Excluded from this release type: Rect */
+
+/** @public */
+export declare interface ResolvedComponentItemConfig extends ResolvedHeaderedItemConfig {
+    readonly type: 'component';
+    readonly content: [];
+    readonly title: string;
+    readonly reorderEnabled: boolean;
+    /**
+     * The name of the component as specified in layout.registerComponent. Mandatory if type is 'component'.
+     */
+    readonly componentType: JsonValue;
+    readonly componentState?: JsonValue;
+}
+
+/** @public */
+export declare namespace ResolvedComponentItemConfig {
+    const defaultReorderEnabled = true;
+    export function resolveComponentTypeName(itemConfig: ResolvedComponentItemConfig): string | undefined;
+    export function createCopy(original: ResolvedComponentItemConfig): ResolvedComponentItemConfig;
+    export function createDefault(componentType?: JsonValue, componentState?: JsonValue, title?: string): ResolvedComponentItemConfig;
+    export function copyComponentType(componentType: JsonValue): JsonValue;
+}
+
+/* Excluded from this release type: ResolvedGroundItemConfig */
+
+/** @public */
+export declare interface ResolvedHeaderedItemConfig extends ResolvedItemConfig {
+    header: ResolvedHeaderedItemConfig.Header | undefined;
+    readonly maximised: boolean;
+}
+
+/** @public */
+export declare namespace ResolvedHeaderedItemConfig {
+    const defaultMaximised = false;
+    export interface Header {
+        readonly show: false | Side | undefined;
+        readonly popout: false | string | undefined;
+        readonly maximise: false | string | undefined;
+        readonly close: string | undefined;
+        readonly minimise: string | undefined;
+        readonly tabDropdown: false | string | undefined;
+    }
+    export namespace Header {
+        export function createCopy(original: Header | undefined, show?: false | Side): Header | undefined;
+    }
+}
+
+/** @public */
+export declare interface ResolvedItemConfig {
+    readonly type: ItemType;
+    readonly content: readonly ResolvedItemConfig[];
+    readonly size: number;
+    readonly sizeUnit: SizeUnitEnum;
+    readonly minSize: number | undefined;
+    readonly minSizeUnit: SizeUnitEnum;
+    readonly id: string;
+    readonly isClosable: boolean;
+}
+
+/** @public */
+export declare namespace ResolvedItemConfig {
+    const defaults: ResolvedItemConfig;
+    /** Creates a copy of the original ResolvedItemConfig using an alternative content if specified */
+    export function createCopy(original: ResolvedItemConfig, content?: ResolvedItemConfig[]): ResolvedItemConfig;
+    export function createDefault(type: ItemType): ResolvedItemConfig;
+    export function isComponentItem(itemConfig: ResolvedItemConfig): itemConfig is ResolvedComponentItemConfig;
+    export function isStackItem(itemConfig: ResolvedItemConfig): itemConfig is ResolvedStackItemConfig;
+    /* Excluded from this release type: isGroundItem */
+}
+
+/** @public */
+export declare interface ResolvedLayoutConfig {
+    readonly root: ResolvedRootItemConfig | undefined;
+    readonly openPopouts: ResolvedPopoutLayoutConfig[];
+    readonly dimensions: ResolvedLayoutConfig.Dimensions;
+    readonly settings: ResolvedLayoutConfig.Settings;
+    readonly header: ResolvedLayoutConfig.Header;
+    readonly resolved: true;
+}
+
+/** @public */
+export declare namespace ResolvedLayoutConfig {
+    export interface Settings {
+        readonly constrainDragToContainer: boolean;
+        readonly reorderEnabled: boolean;
+        readonly popoutWholeStack: boolean;
+        readonly blockedPopoutsThrowError: boolean;
+        /** @deprecated Will be removed in version 3. */
+        readonly closePopoutsOnUnload: boolean;
+        readonly responsiveMode: ResponsiveMode;
+        readonly tabOverlapAllowance: number;
+        readonly reorderOnTabMenuClick: boolean;
+        readonly tabControlOffset: number;
+        readonly popInOnClose: boolean;
+    }
+    export namespace Settings {
+        const defaults: ResolvedLayoutConfig.Settings;
+        export function createCopy(original: Settings): Settings;
+    }
+    export interface Dimensions {
+        readonly borderWidth: number;
+        readonly borderGrabWidth: number;
+        readonly defaultMinItemHeight: number;
+        readonly defaultMinItemHeightUnit: SizeUnitEnum;
+        readonly defaultMinItemWidth: number;
+        readonly defaultMinItemWidthUnit: SizeUnitEnum;
+        readonly headerHeight: number;
+        readonly dragProxyWidth: number;
+        readonly dragProxyHeight: number;
+    }
+    export namespace Dimensions {
+        export function createCopy(original: Dimensions): Dimensions;
+        const defaults: ResolvedLayoutConfig.Dimensions;
+    }
+    export interface Header {
+        readonly show: false | Side;
+        readonly popout: false | string;
+        readonly dock: string;
+        readonly maximise: false | string;
+        readonly minimise: string;
+        readonly close: false | string;
+        readonly tabDropdown: false | string;
+    }
+    export namespace Header {
+        export function createCopy(original: Header): Header;
+        const defaults: ResolvedLayoutConfig.Header;
+    }
+    export function isPopout(config: ResolvedLayoutConfig): config is ResolvedPopoutLayoutConfig;
+    export function createDefault(): ResolvedLayoutConfig;
+    export function createCopy(config: ResolvedLayoutConfig): ResolvedLayoutConfig;
+    export function copyOpenPopouts(original: ResolvedPopoutLayoutConfig[]): ResolvedPopoutLayoutConfig[];
+    /**
+     * Takes a GoldenLayout configuration object and
+     * replaces its keys and values recursively with
+     * one letter counterparts
+     */
+    export function minifyConfig(layoutConfig: ResolvedLayoutConfig): ResolvedLayoutConfig;
+    /**
+     * Takes a configuration Object that was previously minified
+     * using minifyConfig and returns its original version
+     */
+    export function unminifyConfig(minifiedConfig: ResolvedLayoutConfig): ResolvedLayoutConfig;
+}
+
+/** @public */
+export declare interface ResolvedPopoutLayoutConfig extends ResolvedLayoutConfig {
+    readonly parentId: string | null;
+    readonly indexInParent: number | null;
+    readonly window: ResolvedPopoutLayoutConfig.Window;
+}
+
+/** @public */
+export declare namespace ResolvedPopoutLayoutConfig {
+    export interface Window {
+        readonly width: number | null;
+        readonly height: number | null;
+        readonly left: number | null;
+        readonly top: number | null;
+    }
+    export namespace Window {
+        export function createCopy(original: Window): Window;
+        const defaults: ResolvedPopoutLayoutConfig.Window;
+    }
+    export function createCopy(original: ResolvedPopoutLayoutConfig): ResolvedPopoutLayoutConfig;
+}
+
+/**
+ * RootItemConfig is the topmost ResolvedItemConfig specified by the user.
+ * Note that it does not have a corresponding contentItem.  It specifies the one and only child of the Ground ContentItem
+ * Note that RootItemConfig can be an ComponentItem itemConfig.  However when the Ground ContentItem's child is created
+ * a ComponentItem itemConfig will create a Stack with a child ComponentItem.
+ * @public
+ */
+export declare type ResolvedRootItemConfig = ResolvedRowOrColumnItemConfig | ResolvedStackItemConfig | ResolvedComponentItemConfig;
+
+/** @public */
+export declare namespace ResolvedRootItemConfig {
+    export function createCopy(config: ResolvedRootItemConfig): ResolvedRootItemConfig;
+    export function isRootItemConfig(itemConfig: ResolvedItemConfig): itemConfig is ResolvedRootItemConfig;
+}
+
+/** Base for Root or RowOrColumn ItemConfigs
+ * @public
+ */
+export declare interface ResolvedRowOrColumnItemConfig extends ResolvedItemConfig {
+    readonly type: 'row' | 'column';
+    /** Note that RowOrColumn ResolvedItemConfig contents, can contain ComponentItem itemConfigs.  However
+     * when ContentItems are created, these ComponentItem itemConfigs will create a Stack with a child ComponentItem.
+     */
+    readonly content: readonly (ResolvedRowOrColumnItemConfig | ResolvedStackItemConfig | ResolvedComponentItemConfig)[];
+}
+
+/** @public */
+export declare namespace ResolvedRowOrColumnItemConfig {
+    export type ChildItemConfig = ResolvedRowOrColumnItemConfig | ResolvedStackItemConfig | ResolvedComponentItemConfig;
+    export function isChildItemConfig(itemConfig: ResolvedItemConfig): itemConfig is ChildItemConfig;
+    export function createCopy(original: ResolvedRowOrColumnItemConfig, content?: ChildItemConfig[]): ResolvedRowOrColumnItemConfig;
+    export function copyContent(original: readonly ChildItemConfig[]): ChildItemConfig[];
+    export function createDefault(type: 'row' | 'column'): ResolvedRowOrColumnItemConfig;
+}
+
+/** @public */
+export declare interface ResolvedStackItemConfig extends ResolvedHeaderedItemConfig {
+    readonly type: 'stack';
+    readonly content: ResolvedComponentItemConfig[];
+    /** The index of the active item in the Stack.  Only undefined if the Stack is empty. */
+    readonly activeItemIndex: number | undefined;
+}
+
+/** @public */
+export declare namespace ResolvedStackItemConfig {
+    const defaultActiveItemIndex = 0;
+    export function createCopy(original: ResolvedStackItemConfig, content?: ResolvedComponentItemConfig[]): ResolvedStackItemConfig;
+    export function copyContent(original: ResolvedComponentItemConfig[]): ResolvedComponentItemConfig[];
+    export function createDefault(): ResolvedStackItemConfig;
+}
+
+/** @public */
+export declare type ResponsiveMode = 'none' | 'always' | 'onload';
+
+/** @public */
+export declare namespace ResponsiveMode {
+    const none = "none";
+    const always = "always";
+    const onload = "onload";
+}
+
+/** @public */
+export declare type RootItemConfig = RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig;
+
+/** @public */
+export declare namespace RootItemConfig {
+    export function isRootItemConfig(itemConfig: ItemConfig): itemConfig is RootItemConfig;
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: fromResolvedOrUndefined */
+}
+
+/** @public */
+export declare class RowOrColumn extends ContentItem {
+    /* Excluded from this release type: _rowOrColumnParent */
+    /* Excluded from this release type: _childElementContainer */
+    /* Excluded from this release type: _configType */
+    /* Excluded from this release type: _isColumn */
+    /* Excluded from this release type: _splitterSize */
+    /* Excluded from this release type: _splitterGrabSize */
+    /* Excluded from this release type: _dimension */
+    /* Excluded from this release type: _splitter */
+    /* Excluded from this release type: _splitterPosition */
+    /* Excluded from this release type: _splitterMinPosition */
+    /* Excluded from this release type: _splitterMaxPosition */
+    /* Excluded from this release type: __constructor */
+    newComponent(componentType: JsonValue, componentState?: JsonValue, title?: string, index?: number): ComponentItem;
+    addComponent(componentType: JsonValue, componentState?: JsonValue, title?: string, index?: number): number;
+    newItem(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig, index?: number): ContentItem;
+    addItem(itemConfig: RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig, index?: number): number;
+    /**
+     * Add a new contentItem to the Row or Column
+     *
+     * @param contentItem -
+     * @param index - The position of the new item within the Row or Column.
+     *                If no index is provided the item will be added to the end
+     * @param suspendResize - If true the items won't be resized. This will leave the item in
+     *                        an inconsistent state and is only intended to be used if multiple
+     *                        children need to be added in one go and resize is called afterwards
+     *
+     * @returns
+     */
+    addChild(contentItem: ContentItem, index?: number, suspendResize?: boolean): number;
+    /**
+     * Removes a child of this element
+     *
+     * @param contentItem -
+     * @param keepChild - If true the child will be removed, but not destroyed
+     *
+     */
+    removeChild(contentItem: ContentItem, keepChild: boolean): void;
+    /**
+     * Replaces a child of this Row or Column with another contentItem
+     */
+    replaceChild(oldChild: ContentItem, newChild: ContentItem): void;
+    /**
+     * Called whenever the dimensions of this item or one of its parents change
+     */
+    updateSize(force: boolean): void;
+    /* Excluded from this release type: init */
+    toConfig(): ResolvedRowOrColumnItemConfig;
+    /* Excluded from this release type: setParent */
+    /* Excluded from this release type: updateNodeSize */
+    /* Excluded from this release type: setAbsoluteSizes */
+    /* Excluded from this release type: calculateAbsoluteSizes */
+    /* Excluded from this release type: calculateRelativeSizes */
+    /* Excluded from this release type: respectMinItemSize */
+    /* Excluded from this release type: createSplitter */
+    /* Excluded from this release type: getSplitItems */
+    private calculateContentItemMinSize;
+    /* Excluded from this release type: calculateContentItemsTotalMinSize */
+    /* Excluded from this release type: onSplitterDragStart */
+    /* Excluded from this release type: onSplitterDrag */
+    /* Excluded from this release type: onSplitterDragStop */
+}
+
+/** @public */
+export declare namespace RowOrColumn {
+    /* Excluded from this release type: AbsoluteSizes */
+    /* Excluded from this release type: getElementDimensionSize */
+    /* Excluded from this release type: setElementDimensionSize */
+    /* Excluded from this release type: createElement */
+}
+
+/** @public */
+export declare interface RowOrColumnItemConfig extends ItemConfig {
+    type: 'row' | 'column';
+    content: (RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig)[];
+}
+
+/** @public */
+export declare namespace RowOrColumnItemConfig {
+    export type ChildItemConfig = RowOrColumnItemConfig | StackItemConfig | ComponentItemConfig;
+    export function isChildItemConfig(itemConfig: ItemConfig): itemConfig is ChildItemConfig;
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: fromResolved */
+    /* Excluded from this release type: resolveContent */
+}
+
+/** @public */
+export declare type Side = 'top' | 'left' | 'right' | 'bottom';
+
+/** @public */
+export declare namespace Side {
+    const top = "top";
+    const left = "left";
+    const right = "right";
+    const bottom = "bottom";
+}
+
+/**
+ * Length units which can specify the size of a Component Item
+ * @public
+ */
+export declare type SizeUnit = 'px' | '%' | 'fr' | 'em';
+
+/** @public */
+export declare enum SizeUnitEnum {
+    Pixel = "px",
+    Percent = "%",
+    Fractional = "fr",
+    Em = "em"
+}
+
+/** @public */
+export declare namespace SizeUnitEnum {
+    export function tryParse(value: string): SizeUnitEnum | undefined;
+    export function format(value: SizeUnitEnum): SizeUnitEnum;
+}
+
+/* Excluded from this release type: SizeWithUnit */
+
+/** @public */
+export declare class Stack extends ComponentParentableItem {
+    /* Excluded from this release type: _headerConfig */
+    /* Excluded from this release type: _header */
+    /* Excluded from this release type: _childElementContainer */
+    /* Excluded from this release type: _maximisedEnabled */
+    /* Excluded from this release type: _activeComponentItem */
+    /* Excluded from this release type: _dropSegment */
+    /* Excluded from this release type: _dropIndex */
+    /* Excluded from this release type: _contentAreaDimensions */
+    /* Excluded from this release type: _headerSideChanged */
+    /* Excluded from this release type: _initialWantMaximise */
+    /* Excluded from this release type: _initialActiveItemIndex */
+    /* Excluded from this release type: _resizeListener */
+    /* Excluded from this release type: _maximisedListener */
+    /* Excluded from this release type: _minimisedListener */
+    get childElementContainer(): HTMLElement;
+    get header(): Header;
+    get headerShow(): boolean;
+    get headerSide(): Side;
+    get headerLeftRightSided(): boolean;
+    /* Excluded from this release type: contentAreaDimensions */
+    /* Excluded from this release type: initialWantMaximise */
+    get isMaximised(): boolean;
+    get stackParent(): ContentItem;
+    /* Excluded from this release type: __constructor */
+    /* Excluded from this release type: updateSize */
+    /* Excluded from this release type: init */
+    /** @deprecated Use {@link (Stack:class).setActiveComponentItem} */
+    setActiveContentItem(item: ContentItem): void;
+    setActiveComponentItem(componentItem: ComponentItem, focus: boolean, suppressFocusEvent?: boolean): void;
+    /** @deprecated Use {@link (Stack:class).getActiveComponentItem} */
+    getActiveContentItem(): ContentItem | null;
+    getActiveComponentItem(): ComponentItem | undefined;
+    /* Excluded from this release type: focusActiveContentItem */
+    /* Excluded from this release type: setFocusedValue */
+    /* Excluded from this release type: setRowColumnClosable */
+    newComponent(componentType: JsonValue, componentState?: JsonValue, title?: string, index?: number): ComponentItem;
+    addComponent(componentType: JsonValue, componentState?: JsonValue, title?: string, index?: number): number;
+    newItem(itemConfig: ComponentItemConfig, index?: number): ContentItem;
+    addItem(itemConfig: ComponentItemConfig, index?: number): number;
+    addChild(contentItem: ContentItem, index?: number, focus?: boolean): number;
+    removeChild(contentItem: ContentItem, keepChild: boolean): void;
+    /**
+     * Maximises the Item or minimises it if it is already maximised
+     */
+    toggleMaximise(): void;
+    maximise(): void;
+    minimise(): void;
+    /* Excluded from this release type: destroy */
+    toConfig(): ResolvedStackItemConfig;
+    /* Excluded from this release type: onDrop */
+    /* Excluded from this release type: highlightDropZone */
+    /* Excluded from this release type: getArea */
+    /* Excluded from this release type: positionHeader */
+    /* Excluded from this release type: updateNodeSize */
+    /* Excluded from this release type: highlightHeaderDropZone */
+    /* Excluded from this release type: resetHeaderDropZone */
+    /* Excluded from this release type: setupHeaderPosition */
+    /* Excluded from this release type: highlightBodyDropZone */
+    /* Excluded from this release type: handleResize */
+    /* Excluded from this release type: handleMaximised */
+    /* Excluded from this release type: handleMinimised */
+    /* Excluded from this release type: handlePopoutEvent */
+    /* Excluded from this release type: handleHeaderClickEvent */
+    /* Excluded from this release type: handleHeaderTouchStartEvent */
+    /* Excluded from this release type: handleHeaderComponentRemoveEvent */
+    /* Excluded from this release type: handleHeaderComponentFocusEvent */
+    /* Excluded from this release type: handleHeaderComponentStartDragEvent */
+    /* Excluded from this release type: createHeaderConfig */
+    /* Excluded from this release type: emitStateChangedEvent */
+}
+
+/** @public */
+export declare namespace Stack {
+    /* Excluded from this release type: Segment */
+    /* Excluded from this release type: ContentAreaDimension */
+    /* Excluded from this release type: ContentAreaDimensions */
+    /* Excluded from this release type: createElement */
+}
+
+/** @public */
+export declare interface StackItemConfig extends HeaderedItemConfig {
+    type: 'stack';
+    content: ComponentItemConfig[];
+    /** The index of the item in content which is to be active*/
+    activeItemIndex?: number;
+}
+
+/** @public */
+export declare namespace StackItemConfig {
+    /* Excluded from this release type: resolve */
+    /* Excluded from this release type: fromResolved */
+}
+
+/** @public */
+export declare namespace StyleConstants {
+    const defaultComponentBaseZIndex = "auto";
+    const defaultComponentDragZIndex = "32";
+    const defaultComponentStackMaximisedZIndex = "41";
+}
+
+/**
+ * Represents an individual tab within a Stack's header
+ * @public
+ */
+export declare class Tab {
+    /* Excluded from this release type: _layoutManager */
+    /* Excluded from this release type: _componentItem */
+    /* Excluded from this release type: _closeEvent */
+    /* Excluded from this release type: _focusEvent */
+    /* Excluded from this release type: _dragStartEvent */
+    /* Excluded from this release type: _element */
+    /* Excluded from this release type: _titleElement */
+    /* Excluded from this release type: _closeElement */
+    /* Excluded from this release type: _dragListener */
+    /* Excluded from this release type: _isActive */
+    /* Excluded from this release type: _tabClickListener */
+    /* Excluded from this release type: _tabTouchStartListener */
+    /* Excluded from this release type: _closeClickListener */
+    /* Excluded from this release type: _closeTouchStartListener */
+    /* Excluded from this release type: _dragStartListener */
+    /* Excluded from this release type: _contentItemDestroyListener */
+    /* Excluded from this release type: _tabTitleChangedListener */
+    get isActive(): boolean;
+    get componentItem(): ComponentItem;
+    /** @deprecated use {@link (Tab:class).componentItem} */
+    get contentItem(): ComponentItem;
+    get element(): HTMLElement;
+    get titleElement(): HTMLElement;
+    get closeElement(): HTMLElement | undefined;
+    get reorderEnabled(): boolean;
+    set reorderEnabled(value: boolean);
+    /* Excluded from this release type: __constructor */
+    /**
+     * Sets the tab's title to the provided string and sets
+     * its title attribute to a pure text representation (without
+     * html tags) of the same string.
+     */
+    setTitle(title: string): void;
+    /**
+     * Sets this tab's active state. To programmatically
+     * switch tabs, use Stack.setActiveComponentItem( item ) instead.
+     */
+    setActive(isActive: boolean): void;
+    /* Excluded from this release type: destroy */
+    /* Excluded from this release type: setBlurred */
+    /* Excluded from this release type: setFocused */
+    /* Excluded from this release type: onDragStart */
+    /* Excluded from this release type: onContentItemDestroy */
+    /* Excluded from this release type: onTabClickDown */
+    /* Excluded from this release type: onTabTouchStart */
+    /* Excluded from this release type: onCloseClick */
+    /* Excluded from this release type: onCloseTouchStart */
+    /* Excluded from this release type: notifyClose */
+    /* Excluded from this release type: notifyFocus */
+    /* Excluded from this release type: enableReorder */
+    /* Excluded from this release type: disableReorder */
+}
+
+/** @public */
+export declare namespace Tab {
+    /* Excluded from this release type: CloseEvent */
+    /* Excluded from this release type: FocusEvent */
+    /* Excluded from this release type: DragStartEvent */
+}
+
+/* Excluded from this release type: TransitionIndicator */
+
+/* Excluded from this release type: UndefinableSizeWithUnit */
+
+/** @public */
+export declare class VirtualLayout extends LayoutManager {
+    /**
+     * @deprecated Use {@link (VirtualLayout:class).bindComponentEvent} and
+     * {@link (VirtualLayout:class).unbindComponentEvent} with virtual components
+     */
+    getComponentEvent: VirtualLayout.GetComponentEventHandler | undefined;
+    /**
+     * @deprecated Use {@link (VirtualLayout:class).bindComponentEvent} and
+     * {@link (VirtualLayout:class).unbindComponentEvent} with virtual components
+     */
+    releaseComponentEvent: VirtualLayout.ReleaseComponentEventHandler | undefined;
+    bindComponentEvent: VirtualLayout.BindComponentEventHandler | undefined;
+    unbindComponentEvent: VirtualLayout.UnbindComponentEventHandler | undefined;
+    /* Excluded from this release type: _bindComponentEventHanlderPassedInConstructor */
+    /* Excluded from this release type: _creationTimeoutPassed */
+    /**
+     * @param container - A Dom HTML element. Defaults to body
+     * @param bindComponentEventHandler - Event handler to bind components
+     * @param bindComponentEventHandler - Event handler to unbind components
+     * If bindComponentEventHandler is defined, then constructor will be determinate. It will always call the init()
+     * function and the init() function will always complete. This means that the bindComponentEventHandler will be called
+     * if constructor is for a popout window. Make sure bindComponentEventHandler is ready for events.
+     */
+    constructor(container?: HTMLElement, bindComponentEventHandler?: VirtualLayout.BindComponentEventHandler, unbindComponentEventHandler?: VirtualLayout.UnbindComponentEventHandler);
+    /** @deprecated specify layoutConfig in {@link (LayoutManager:class).loadLayout} */
+    constructor(config: LayoutConfig, container?: HTMLElement);
+    /* Excluded from this release type: __constructor */
+    destroy(): void;
+    /**
+     * Creates the actual layout. Must be called after all initial components
+     * are registered. Recurses through the configuration and sets up
+     * the item tree.
+     *
+     * If called before the document is ready it adds itself as a listener
+     * to the document.ready event
+     * @deprecated LayoutConfig should not be loaded in {@link (LayoutManager:class)} constructor, but rather in a
+     * {@link (LayoutManager:class).loadLayout} call.  If LayoutConfig is not specified in {@link (LayoutManager:class)} constructor,
+     * then init() will be automatically called internally and should not be called externally.
+     */
+    init(): void;
+    /**
+     * Clears existing HTML and adjusts style to make window suitable to be a popout sub window
+     * Curently is automatically called when window is a subWindow and bindComponentEvent is not passed in the constructor
+     * If bindComponentEvent is not passed in the constructor, the application must either call this function explicitly or
+     * (preferably) make the window suitable as a subwindow.
+     * In the future, it is planned that this function is NOT automatically called in any circumstances.  Applications will
+     * need to determine whether a window is a Golden Layout popout window and either call this function explicitly or
+     * hide HTML not relevant to the popout.
+     * See apitest for an example of how HTML is hidden when popout windows are displayed
+     */
+    clearHtmlAndAdjustStylesForSubWindow(): void;
+    /**
+     * Will add button if not popinOnClose specified in settings
+     * @returns true if added otherwise false
+     */
+    checkAddDefaultPopinButton(): boolean;
+    /* Excluded from this release type: bindComponent */
+    /* Excluded from this release type: unbindComponent */
+}
+
+/** @public */
+export declare namespace VirtualLayout {
+    /**
+     * @deprecated Use virtual components with {@link (VirtualLayout:class).bindComponentEvent} and
+     * {@link (VirtualLayout:class).unbindComponentEvent} events.
+     */
+    export type GetComponentEventHandler = (this: void, container: ComponentContainer, itemConfig: ResolvedComponentItemConfig) => ComponentContainer.Component;
+    /**
+     * @deprecated Use virtual components with {@link (VirtualLayout:class).bindComponentEvent} and
+     * {@link (VirtualLayout:class).unbindComponentEvent} events.
+     */
+    export type ReleaseComponentEventHandler = (this: void, container: ComponentContainer, component: ComponentContainer.Component) => void;
+    export type BindComponentEventHandler = (this: void, container: ComponentContainer, itemConfig: ResolvedComponentItemConfig) => ComponentContainer.BindableComponent;
+    export type UnbindComponentEventHandler = (this: void, container: ComponentContainer) => void;
+    export type BeforeVirtualRectingEvent = (this: void) => void;
+    /* Excluded from this release type: createLayoutManagerConstructorParameters */
+}
+
+/* Excluded from this release type: WidthAndHeight */
+
+/* Excluded from this release type: WidthOrHeightPropertyName */
+
+export { }