@xh/hoist 57.0.0 → 57.0.2

package/build/types/desktop/cmp/button/ThemeToggleButton.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export type ThemeToggleButtonProps = ButtonProps;
+/**
+ * Convenience Button preconfigured for use as a trigger for light/dark theme toggling.
+ */
+export declare const ThemeToggleButton: import("react").FC<ThemeToggleButtonProps>, themeToggleButton: import("@xh/hoist/core").ElementFactory<ThemeToggleButtonProps>;

package/build/types/desktop/cmp/button/WhatsNewButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/desktop/cmp/button/Button';
+import '@xh/hoist/desktop/register';
+export type WhatsNewButtonProps = ButtonProps;
+/**
+ * Button that conditionally renders when there is a changelog entry for the current app version
+ * that has yet to be viewed by the current user.
+ *
+ * See {@link ChangelogService} for details on how to enable this overall system.
+ */
+export declare const WhatsNewButton: import("react").FC<WhatsNewButtonProps>, whatsNewButton: import("@xh/hoist/core").ElementFactory<WhatsNewButtonProps>;

package/build/types/desktop/cmp/button/index.d.ts

@@ -0,0 +1,15 @@
+export * from './Button';
+export * from './AppMenuButton';
+export * from './ButtonGroup';
+export * from './ColAutosizeButton';
+export * from './ColChooserButton';
+export * from './DashCanvasAddViewButton';
+export * from './ExportButton';
+export * from './FeedbackButton';
+export * from './LaunchAdminButton';
+export * from './LogoutButton';
+export * from './ModalToggleButton';
+export * from './OptionsButton';
+export * from './RefreshButton';
+export * from './RestoreDefaultsButton';
+export * from './ThemeToggleButton';

package/build/types/desktop/cmp/clipboard/ClipboardButton.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/desktop/cmp/button';
+import '@xh/hoist/desktop/register';
+export interface ClipboardButtonProps extends ButtonProps {
+    /** Function returning the text to copy. May be async. */
+    getCopyText: () => string | Promise<string>;
+    /** Message to be displayed in a toast when copy is complete. */
+    successMessage?: string;
+}
+/**
+ * Button to copy text to the clipboard.
+ */
+export declare const ClipboardButton: import("react").FC<ClipboardButtonProps>, clipboardButton: import("@xh/hoist/core").ElementFactory<ClipboardButtonProps>;

package/build/types/desktop/cmp/clipboard/ClipboardMenuItem.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+import { ClipboardButtonProps } from './ClipboardButton';
+/**
+ * Convenience wrapper for a ClipboardButton to be rendered as a Blueprint menu item.
+ */
+export declare const ClipboardMenuItem: import("react").FC<ClipboardButtonProps>, clipboardMenuItem: import("@xh/hoist/core").ElementFactory<ClipboardButtonProps>;

package/build/types/desktop/cmp/clipboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ClipboardButton';
+export * from './ClipboardMenuItem';

package/build/types/desktop/cmp/contextmenu/ContextMenu.d.ts

@@ -0,0 +1,21 @@
+import { HoistProps, MenuItemLike } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactElement } from 'react';
+/**
+ * A context menu is specified as  an array of items, a function to generate one from a click, or
+ * a full element representing a contextMenu Component.
+ */
+export type ContextMenuSpec = MenuItemLike[] | ((e: MouseEvent) => MenuItemLike[]) | ReactElement;
+export interface ContextMenuProps extends HoistProps {
+    menuItems: MenuItemLike[];
+}
+/**
+ * ContextMenu
+ *
+ * Not typically used directly by applications.  To add a Context Menu to an application
+ * see ContextMenuHost, or the `contextMenu` prop on panel.
+ *
+ * See {@link GridContextMenu} to specify a context menu on Grid and DataView components.
+ * That API will receive specific information about the current selection
+ */
+export declare const ContextMenu: import("react").FC<ContextMenuProps>, contextMenu: import("@xh/hoist/core").ElementFactory<ContextMenuProps>;

package/build/types/desktop/cmp/contextmenu/index.d.ts

@@ -0,0 +1 @@
+export * from './ContextMenu';

package/build/types/desktop/cmp/dash/DashConfig.d.ts

@@ -0,0 +1,33 @@
+import { MenuItemLike, PersistOptions } from '@xh/hoist/core';
+/**
+ * Base interface for {@link DashCanvasConfig} and {@link DashContainerConfig}.
+ */
+export interface DashConfig<VSPEC, VSTATE> {
+    /**
+     * A collection of viewSpecs, each describing a type of view that can be displayed in this
+     * container.
+     */
+    viewSpecs: VSPEC[];
+    /** Properties to be set on all viewSpecs.  Merges deeply. */
+    viewSpecDefaults?: Partial<VSPEC>;
+    /** Default layout state for this container.*/
+    initialState?: VSTATE[];
+    /** Prevent re-arranging views by dragging and dropping.*/
+    layoutLocked?: boolean;
+    /** Prevent adding and removing views. */
+    contentLocked?: boolean;
+    /** Prevent renaming views. */
+    renameLocked?: boolean;
+    /** Options governing persistence. */
+    persistWith?: PersistOptions;
+    /** Text to display when the container is empty. */
+    emptyText?: string;
+    /** Text to display on the add view button. */
+    addViewButtonText?: string;
+    /**
+     * Array of RecordActions, configs or token strings, with which to create additional dash
+     * context menu items. Extra menu items will appear in the menu section below the 'Add' action,
+     * including when the dash container is empty.
+     */
+    extraMenuItems?: MenuItemLike[];
+}

package/build/types/desktop/cmp/dash/DashModel.d.ts

@@ -0,0 +1,19 @@
+import { HoistModel, PersistenceProvider } from '@xh/hoist/core';
+/**
+ * Base Model for {@link DashCanvasModel} and {@link DashContainerModel}.
+ */
+export declare abstract class DashModel<VSPEC, VSTATE, VMODEL> extends HoistModel {
+    viewSpecs: VSPEC[];
+    state: VSTATE[];
+    viewModels: VMODEL[];
+    layoutLocked: boolean;
+    contentLocked: boolean;
+    renameLocked: boolean;
+    emptyText: string;
+    addViewButtonText: string;
+    extraMenuItems: any[];
+    abstract get isEmpty(): boolean;
+    protected restoreState: any;
+    protected provider: PersistenceProvider;
+    constructor();
+}

package/build/types/desktop/cmp/dash/DashViewModel.d.ts

@@ -0,0 +1,52 @@
+import { HoistModel, MenuItemLike, PlainObject, RefreshMode, RenderMode } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactElement } from 'react';
+import { DashViewSpec } from './DashViewSpec';
+export type DashViewState = PlainObject;
+/**
+ * Model for a content item within a DashContainer or DashCanvas.
+ * Supports state management, a refresh context, and active state.
+ *
+ * This model is not created directly within applications. Instead, specify a
+ * DashViewSpec. Individual instances of this will then be loaded dynamically from
+ * user state or user actions.
+ *
+ * Content hosted within this view can use this model at runtime to access and set state
+ * for the view or access other information.
+ */
+export declare class DashViewModel<T extends DashViewSpec = DashViewSpec> extends HoistModel {
+    id: string;
+    /** DashViewSpec used to create this view. */
+    viewSpec: T;
+    /**
+     * Parent DashContainerModel or DashCanvasModel. Provided by the container when
+     * constructing these models - no need to specify manually.
+     */
+    containerModel: any;
+    /** Title with which to initialize the view. */
+    title: string;
+    /** Icon with which to initialize the view. */
+    icon: ReactElement;
+    /** State with which to initialize the view. */
+    viewState: DashViewState;
+    /** Extra menu items for the context menu. */
+    extraMenuItems: MenuItemLike[];
+    refreshContextModel: any;
+    isActive: boolean;
+    get renderMode(): RenderMode;
+    get refreshMode(): RefreshMode;
+    constructor({ id, viewSpec, icon, title, viewState, containerModel }: DashViewConfig<T>);
+    /**
+     * Modify a single key on this model's viewState
+     */
+    setViewStateKey(key: string, value: any): void;
+}
+/** @internal */
+export interface DashViewConfig<T extends DashViewSpec = DashViewSpec> {
+    id: string;
+    viewSpec: T;
+    icon?: ReactElement;
+    title?: string;
+    viewState?: DashViewState;
+    containerModel?: any;
+}

package/build/types/desktop/cmp/dash/DashViewSpec.d.ts

@@ -0,0 +1,41 @@
+import { Content, Thunkable } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactElement } from 'react';
+/**
+ * Spec used to generate DashViews and DashViewModels within a DashContainer or DashCanvas.
+ *
+ * This is a base interface for {@link DashContainerViewSpec} and {@link DashCanvasViewSpec}
+ */
+export interface DashViewSpec {
+    /** Unique identifier of the DashViewSpec. */
+    id: string;
+    /** Content to be rendered by this DashView. */
+    content: Content;
+    /** Title text added to the tab header. */
+    title: string;
+    /** An icon placed at the left-side of the tab header. */
+    icon?: ReactElement;
+    /**
+     * Group name to display within the add view component. The default context menu will
+     * automatically group its available views if provided.
+     */
+    groupName?: string;
+    /**
+     * True to prevent any instances of this view. References to this view in state will
+     * be quietly dropped. Default false.
+     */
+    omit?: Thunkable<boolean>;
+    /** True to prevent multiple instances of this view. Default false. */
+    unique?: boolean;
+    /**
+     * True (default) to allow adding new instances of this view. References to this view in
+     * state will be respected.
+     */
+    allowAdd?: boolean;
+    /** True (default) to allow removing instances from the DashContainer. */
+    allowRemove?: boolean;
+    /** True (default) to allow renaming the view. */
+    allowRename?: boolean;
+    /** Additional properties to store on the DashView */
+    [x: string]: any;
+}

package/build/types/desktop/cmp/dash/canvas/DashCanvas.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { HoistProps } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import 'react-grid-layout/css/styles.css';
+import './DashCanvas.scss';
+import { DashCanvasModel } from './DashCanvasModel';
+export type DashCanvasProps = HoistProps<DashCanvasModel>;
+/**
+ * Dashboard-style container that allows users to drag-and-drop child widgets into flexible layouts.
+ *
+ * Unlike its cousin {@link DashContainer}, this component scales the width only of its child
+ * widgets as its overall size changes, leaving heights unchanged and scrolling internally as
+ * necessary. This makes it a good candidate for report-style dashboards containing lots of content
+ * that is unlikely to fit or compress nicely on smaller screens. Consider DashContainer when
+ * a space-filling layout is a priority.
+ *
+ * @see DashCanvasModel
+ */
+export declare const DashCanvas: import("react").FC<DashCanvasProps>, dashCanvas: import("@xh/hoist/core").ElementFactory<DashCanvasProps>;

package/build/types/desktop/cmp/dash/canvas/DashCanvasModel.d.ts

@@ -0,0 +1,104 @@
+/// <reference types="react" />
+import { DashCanvasViewModel, DashCanvasViewSpec, DashConfig, DashViewState, DashModel } from '../';
+import '@xh/hoist/desktop/register';
+export interface DashCanvasConfig extends DashConfig<DashCanvasViewSpec, DashCanvasItemState> {
+    /** Total number of columns (x coordinates for views correspond with column numbers). */
+    columns?: number;
+    /** Height of each row in pixels (y coordinates for views correspond with row numbers). */
+    rowHeight?: number;
+    /** Whether views should "compact" vertically to condense vertical space. */
+    compact?: boolean;
+    /** Between items [x,y] in pixels. */
+    margin?: [number, number];
+    /** Maximum number of rows permitted for this container. */
+    maxRows?: number;
+    /** Padding inside the container [x, y] in pixels. */
+    containerPadding?: [number, number];
+}
+export interface DashCanvasItemState {
+    layout: DashCanvasItemLayout;
+    title?: string;
+    viewSpecId: string;
+    state?: DashViewState;
+}
+export interface DashCanvasItemLayout {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * Model for {@link DashCanvas}, managing all configurable options for the component and publishing
+ * the observable state of its current widgets and their layout.
+ */
+export declare class DashCanvasModel extends DashModel<DashCanvasViewSpec, DashCanvasItemState, DashCanvasViewModel> {
+    columns: number;
+    rowHeight: number;
+    compact: boolean;
+    margin: [number, number];
+    containerPadding: [number, number];
+    maxRows: number;
+    /** Current number of rows in canvas */
+    get rows(): number;
+    get isEmpty(): boolean;
+    layout: any[];
+    ref: import("react").RefObject<HTMLElement> & ((instance: HTMLElement) => void);
+    isResizing: boolean;
+    private scrollbarVisible;
+    private isLoadingState;
+    get rglLayout(): any[];
+    constructor({ viewSpecs, viewSpecDefaults, initialState, layoutLocked, contentLocked, renameLocked, persistWith, emptyText, addViewButtonText, columns, rowHeight, compact, margin, maxRows, containerPadding, extraMenuItems }: DashCanvasConfig);
+    /** Removes all views from the canvas */
+    clear(): void;
+    /**
+     * Restore the initial state as specified by the application at construction time. This is the
+     * state without any persisted state or user changes applied.
+     *
+     * This method will clear the persistent state saved for this component, if any.
+     */
+    restoreDefaults(): void;
+    /**
+     * Adds a view to the DashCanvas
+     * @param specId - DashCanvasViewSpec id to add to the container
+     * @param opts - additional options. Note `position` will accept another view's ID in addition
+     *      to the enumerated values: the new view will be added in that view's current position.
+     */
+    addView(specId: string, opts?: {
+        title?: string;
+        position?: 'first' | 'last' | 'nextAvailable' | string;
+        state?: any;
+        width?: number;
+        height?: number;
+    }): DashCanvasViewModel;
+    /**
+     * Remove a view from the DashCanvas
+     * @param id - DashCanvasViewModel id to remove from the container
+     */
+    removeView(id: string): void;
+    /**
+     * Replace a view in the DashCanvas with a different view, keeping the existing layout
+     * @param id - id of view model to be replaced
+     * @param newSpecId - id of view spec to insert
+     */
+    replaceView(id: string, newSpecId: string): void;
+    /** Rename a view in the DashCanvas. */
+    renameView(id: string): void;
+    /** Scrolls a DashCanvasView into view. */
+    ensureViewVisible(id: string): void;
+    private getLayoutFromPosition;
+    private addViewInternal;
+    onRglLayoutChange(rglLayout: any): void;
+    private setLayout;
+    private loadState;
+    private publishState;
+    private buildState;
+    private genViewId;
+    private get viewState();
+    private getView;
+    private getViewLayout;
+    private setViewLayout;
+    private getSpec;
+    private hasSpec;
+    private getViewsBySpecId;
+    private getNextAvailablePosition;
+}

package/build/types/desktop/cmp/dash/canvas/DashCanvasViewModel.d.ts

@@ -0,0 +1,27 @@
+import { DashCanvasViewSpec } from '@xh/hoist/desktop/cmp/dash';
+import { DashViewConfig, DashViewModel } from '../DashViewModel';
+import '@xh/hoist/desktop/register';
+import { ReactNode } from 'react';
+/**
+ * Model for a content item within a DashCanvas.
+ */
+export declare class DashCanvasViewModel extends DashViewModel<DashCanvasViewSpec> {
+    /** True (default) to allow duplicating the view. */
+    allowDuplicate: boolean;
+    /** Hide the Header Panel for the view? Default false. */
+    hidePanelHeader: boolean;
+    /** Hide the menu button for the view? Default false. */
+    hideMenuButton: boolean;
+    /** Should the view resize its height to fit its contents? */
+    autoHeight: boolean;
+    /** Additional items to include in header. */
+    headerItems: ReactNode[];
+    ref: import("react").RefObject<HTMLElement> & ((instance: HTMLElement) => void);
+    constructor(cfg: DashViewConfig<DashCanvasViewSpec>);
+    get positionParams(): any;
+    /** Scrolls the DashCanvasView into view */
+    ensureVisible(): void;
+    onContentsResized({ height }: {
+        height: any;
+    }): void;
+}

package/build/types/desktop/cmp/dash/canvas/DashCanvasViewSpec.d.ts

@@ -0,0 +1,30 @@
+import { DashViewSpec } from '@xh/hoist/desktop/cmp/dash/DashViewSpec';
+import '@xh/hoist/desktop/register';
+/**
+ * Spec used to generate DashCanvasViews and DashCanvasViewModels within a {@link DashCanvas}.
+ *
+ * This class is not typically created directly within applications. Instead, specify as plain
+ * object configs via the `DashCanvasModel.viewSpecs` constructor config.
+ */
+export interface DashCanvasViewSpec extends DashViewSpec {
+    /** Initial height of view when added to canvas (default 5). */
+    height?: number;
+    /** Initial width of view when added to canvas (default 5). */
+    width?: number;
+    /** Maximum height of the view (default undefined). */
+    maxHeight?: number;
+    /** Minimum height of the view (default undefined). */
+    minHeight?: number;
+    /** Maximum width of the view (default undefined). */
+    maxWidth?: number;
+    /** Minimum width of the view (default undefined). */
+    minWidth?: number;
+    /** True to hide the panel header (default false). */
+    hidePanelHeader?: boolean;
+    /** True to hide the panel header menu button (default false). */
+    hideMenuButton?: boolean;
+    /** True to set height automatically based on content height (default false). */
+    autoHeight?: boolean;
+    /** True (default) to allow duplicating the view. */
+    allowDuplicate?: boolean;
+}

package/build/types/desktop/cmp/dash/canvas/impl/DashCanvasContextMenu.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Context menu to add items to a DashCanvas
+ *
+ * Available view specs are listed in their defined order, optionally
+ * grouped by their 'groupName' property
+ * @internal
+ */
+export declare const dashCanvasContextMenu: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

package/build/types/desktop/cmp/dash/canvas/impl/DashCanvasView.d.ts

@@ -0,0 +1,12 @@
+import { DashCanvasViewModel } from '../DashCanvasViewModel';
+/**
+ * Implementation component to show an item within a DashCanvas.  This component
+ * is used by DashCanvas's internal implementation to:
+ *
+ *   - Mount/unmount its contents according to `DashCanvasViewSpec.renderMode`.
+ *   - Track and trigger refreshes according to `DashCanvasViewSpec.refreshMode`.
+ *   - Stretch its contents using a flex layout.
+ *
+ * @internal
+ */
+export declare const dashCanvasView: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<DashCanvasViewModel>>;

package/build/types/desktop/cmp/dash/canvas/impl/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Used to create view menu items (for adding or replacing views)
+ * @internal
+ */
+export declare function createViewMenuItems({ dashCanvasModel, position, viewId, replaceExisting }: {
+    dashCanvasModel: any;
+    position?: any;
+    viewId?: any;
+    replaceExisting?: boolean;
+}): any[];

package/build/types/desktop/cmp/dash/container/DashContainer.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { HoistProps } from '@xh/hoist/core';
+import './DashContainer.scss';
+import { DashContainerModel } from './DashContainerModel';
+export type DashContainerProps = HoistProps<DashContainerModel>;
+/**
+ * Display a set of child components in accordance with a DashContainerModel.
+ */
+export declare const DashContainer: import("react").FC<DashContainerProps>, dashContainer: import("@xh/hoist/core").ElementFactory<DashContainerProps>;

package/build/types/desktop/cmp/dash/container/DashContainerModel.d.ts

@@ -0,0 +1,143 @@
+/// <reference types="react" />
+import { PlainObject, RefreshMode, RenderMode, TaskObserver } from '@xh/hoist/core';
+import { GoldenLayout } from '@xh/hoist/kit/golden-layout';
+import { DashViewModel, DashViewState } from '../DashViewModel';
+import { DashContainerViewSpec } from './DashContainerViewSpec';
+import { DashModel, DashConfig } from '../';
+export interface DashContainerConfig extends DashConfig<DashContainerViewSpec, DashViewState> {
+    /** Strategy for rendering DashContainerViews. Can also be set per-view in `viewSpecs`*/
+    renderMode?: RenderMode;
+    /** Strategy for refreshing DashContainerViews. Can also be set per-view in `viewSpecs`*/
+    refreshMode?: RefreshMode;
+    /** True to include a button in each stack header showing the dash context menu. */
+    showMenuButton?: boolean;
+    /** Between items in pixels. */
+    margin?: number;
+    /**
+     * Custom settings to be passed to the GoldenLayout instance.
+     * @see http://golden-layout.com/docs/Config.html
+     */
+    goldenLayoutSettings?: PlainObject;
+}
+/**
+ * Model for a DashContainer, representing its contents and layout state.
+ *
+ * This model provides support for managing dash views, adding new views on the fly,
+ * and tracking / loading state.
+ *
+ * State should be structured as nested arrays of container objects, according to
+ * GoldenLayout's content config. Supported container types are `row`, `column` and `stack`.
+ * Child containers and views should be provided as an array under the `contents` key.
+ *
+ *      + `row` lay out its children horizontally.
+ *      + `column` lays out its children vertically.
+ *      + `stack` lays out its children as tabs. `stacks` can only contain `views` (more below)
+ *
+ * The children of `row` and `column` containers can be sized by providing width or height values.
+ * Numeric values represent relative sizes, expressed as a percentage of the available space.
+ * Pixel values can be provided as a string (e.g. '100px'), which will be converted to a relative
+ * size at parse time. Any unaccounted for space will be divided equally across the remaining children.
+ *
+ * We differ from GoldenLayout by offering a new type `view`. These should be configured as
+ * id references to the provided DashContainerViewSpec, e.g. `{type: `view`, id: ViewSpec.id}`.
+ * Use instead of the `component` and `react-component` types provided by GoldenLayout.
+ *
+ * Note that loading state will destroy and reinitialize all components - do so sparingly!
+ *
+ * @example
+ * ```
+ * [{
+ *     type: 'row',
+ *     contents: [
+ *          // The first child of this row has pixel width of '200px'.
+ *          // The column will take the remaining width.
+ *         {
+ *             type: 'stack',
+ *             width: '200px',
+ *             contents: [
+ *                 {type: 'view', id: 'viewId'},
+ *                 {type: 'view', id: 'viewId'}
+ *             ]
+ *         },
+ *         {
+ *             type: 'column',
+ *             contents: [
+ *                 // Relative height of 40%. The remaining 60% will be split equally by the other views.
+ *                 {type: 'view', id: 'viewId', height: 40},
+ *                 {type: 'view', id: 'viewId'},
+ *                 {type: 'view', id: 'viewId'}
+ *             ]
+ *         }
+ *     ]
+ * }]
+ * ```
+ *
+ * @see http://golden-layout.com/docs/ItemConfig.html
+ * @see http://golden-layout.com/tutorials/getting-started-react.html
+ */
+export declare class DashContainerModel extends DashModel<DashContainerViewSpec, DashViewState, DashViewModel> {
+    showMenuButton: boolean;
+    renderMode: RenderMode;
+    refreshMode: RefreshMode;
+    goldenLayoutSettings: PlainObject;
+    margin: number;
+    get isEmpty(): boolean;
+    goldenLayout: GoldenLayout;
+    containerRef: import("react").RefObject<HTMLElement> & ((instance: HTMLElement) => void);
+    modelLookupContext: any;
+    loadingStateTask: TaskObserver;
+    constructor({ viewSpecs, viewSpecDefaults, initialState, renderMode, refreshMode, layoutLocked, contentLocked, renameLocked, showMenuButton, margin, goldenLayoutSettings, persistWith, emptyText, addViewButtonText, extraMenuItems }: DashContainerConfig);
+    /**
+     * Restore the initial state as specified by the application at construction time. This is the
+     * state without any persisted state or user changes applied.
+     *
+     * This method will clear the persistent state saved for this component, if any.
+     */
+    restoreDefaultsAsync(): Promise<void>;
+    /**
+     * Load state into the DashContainer, recreating its layout and contents
+     * @param state - State to load
+     */
+    loadStateAsync(state: any): Promise<void>;
+    /**
+     * Add a view to the container.
+     *
+     * @param specId - DashContainerViewSpec id to add to the container
+     * @param container - GoldenLayout container to add it to. If not provided, will be added to the root container.
+     * @param index - An optional index that determines at which position the new item should be added.
+     */
+    addView(specId: string, container?: any, index?: number): void;
+    /**
+     * Remove a view from the container.
+     * @param id - DashViewModel id to remove from the container
+     */
+    removeView(id: string): void;
+    /**
+     * Initiate field renaming for a given view
+     * @param id - DashViewModel id to rename
+     */
+    renameView(id: string): void;
+    onResize(): void;
+    private updateState;
+    private publishState;
+    private onItemDestroyed;
+    private getViewSpec;
+    private getItems;
+    private getItemsBySpecId;
+    private getItemByViewModel;
+    get viewState(): {};
+    private getViewModel;
+    private addViewModel;
+    private removeViewModel;
+    private onStackCreated;
+    private showContextMenu;
+    private refreshActiveViews;
+    private onStackActiveItemChange;
+    private updateTabHeaders;
+    private insertTitleForm;
+    private showTitleForm;
+    private hideTitleForm;
+    private createGoldenLayout;
+    private destroyGoldenLayout;
+    destroy(): void;
+}

package/build/types/desktop/cmp/dash/container/DashContainerViewSpec.d.ts

@@ -0,0 +1,17 @@
+import { DashViewSpec } from '@xh/hoist/desktop/cmp/dash/DashViewSpec';
+import { RefreshMode, RenderMode } from '@xh/hoist/core';
+/**
+ * Spec used to generate DashContainerViews and DashContainerViewModels.
+ */
+export interface DashContainerViewSpec extends DashViewSpec {
+    /**
+     *  Strategy for rendering this DashContainerView. If null, will default to its container's
+     *  mode. See enum for description of supported modes.
+     */
+    renderMode?: RenderMode;
+    /**
+     * Strategy for refreshing this DashView. If null, will default to its container's mode.
+     * See enum for description of supported modes.
+     */
+    refreshMode?: RefreshMode;
+}

package/build/types/desktop/cmp/dash/container/impl/DashContainerContextMenu.d.ts

@@ -0,0 +1,15 @@
+import { DashContainerModel } from '../DashContainerModel';
+/**
+ * Context menu for title bar/tabs of a stack in a DashContainer.
+ *
+ * Available view specs are listed in their defined order, optionally
+ * grouped by their `groupName` property
+ *
+ * @internal
+ */
+export declare const dashContainerContextMenu: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;
+/**
+ * 'Add View' menu button to display in an empty DashContainer.
+ * @internal
+ */
+export declare const dashContainerAddViewButton: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<DashContainerModel>>;

package/build/types/desktop/cmp/dash/container/impl/DashContainerMenuButton.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Button and popover for displaying the context menu. Apps can control whether this button is
+ * displayed via DashContainerModel's `showMenuButton` config.
+ *
+ * @internal
+ */
+export declare const dashContainerMenuButton: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;