@xh/hoist 82.0.1 → 82.0.2

package/build/types/core/model/UsesSpec.d.ts

@@ -0,0 +1,49 @@
+import { HoistModel, ModelSelector, ModelPublishMode } from './';
+/**
+ * Returns a ModelSpec to define how a functional HoistComponent should source its primary backing
+ * HoistModel from props or context. Use this option when your component expects its parent to
+ * provide its model (or a config to create one).
+ *
+ * Hoist will look for a model instance in either props or context. If required and so specified,
+ * the model can also be created on demand from either a config passed via props or its class defaults.
+ *
+ * The resolved/constructed model instance will be provided to the component via props and placed
+ * in context for access by all subcomponents.
+ *
+ * Note that any model created via `createFromConfig` or `createDefault` will be considered to be
+ * 'owned' by the receiving component and treated as if it were specified using `create()`: if it
+ * implements loading it will be loaded on component mount, and it will always be destroyed
+ * on component unmount.
+ *
+ * @param selector - specification of Model to use, or '*' (default) to accept the
+ *      closest context model, without specifying any particular class.
+ * @param opts - additional options
+ */
+export declare function uses<T extends HoistModel>(selector: ModelSelector<T>, { fromContext, publishMode, createFromConfig, createDefault, optional }?: UsesOptions): UsesSpec<T>;
+export interface UsesOptions {
+    /** True (default) to look for a suitable model in context if not sourced via props.*/
+    fromContext?: boolean;
+    /** Mode for publishing this model to context.*/
+    publishMode?: ModelPublishMode;
+    /**
+     * True (default) to accept model config from props and construct an instance on-demand.
+     * Selector must be a HoistModel Class.
+     */
+    createFromConfig?: boolean;
+    /**
+     * True to create a model if none provided.
+     * Selector must be a HoistModel Class, or a custom function may be provided for this argument.
+     */
+    createDefault?: boolean | (() => HoistModel);
+    /** True to specify a model that is optional.  Default false. */
+    optional?: boolean;
+}
+export declare class UsesSpec<T extends HoistModel> {
+    fromContext: boolean;
+    publishMode: ModelPublishMode;
+    optional: boolean;
+    selector: ModelSelector<T>;
+    createFromConfig: boolean;
+    createDefault: boolean;
+    constructor(selector: any, fromContext: any, publishMode: any, createFromConfig: any, createDefault: any, optional: any);
+}

package/build/types/core/model/index.d.ts

@@ -0,0 +1,10 @@
+export * from './HoistModel';
+export * from './RefreshContextModel';
+export * from './ManagedRefreshContextModel';
+export * from './RootRefreshContextModel';
+export * from './ModelSelector';
+export * from './ModelLookup';
+export * from './ModelSpec';
+export * from './CreatesSpec';
+export * from './UsesSpec';
+export * from './Hooks';

package/build/types/core/persist/PersistOptions.d.ts

@@ -0,0 +1,46 @@
+import { Class } from 'type-fest';
+import { DebounceSpec, PersistenceProvider, PersistenceProviderConfig } from '../';
+import type { DashViewModel } from '@xh/hoist/desktop/cmp/dash';
+import type { ViewManagerModel } from '@xh/hoist/cmp/viewmanager';
+/**
+ * Built-in Hoist PersistenceProviders.
+ */
+export type PersistenceProviderType = 'pref' | 'localStorage' | 'sessionStorage' | 'dashView' | 'viewManager' | 'custom';
+export interface PersistOptions {
+    /** Dot delimited path to store state. */
+    path?: string;
+    /** Debounce interval in ms, or a lodash debounce config. */
+    debounce?: DebounceSpec;
+    /**
+     * Delay (in ms) to wait after state has been read before listening for further state changes.
+     */
+    settleTime?: number;
+    /**
+     * Type of PersistenceProvider to create. Specify as one of the built-in string types,
+     * or a subclass of PersistenceProvider.
+     *
+     * If not provided, defaulted to one of the built-in string types based on the presence of
+     * `prefKey`, `localStorageKey`, `dashViewModel`, 'viewManagerModel', or `getData/setData`.
+     */
+    type?: PersistenceProviderType | Class<PersistenceProvider, [PersistenceProviderConfig]>;
+    /** Predefined Hoist application Preference key used to store state. */
+    prefKey?: string;
+    /** Browser local storage key used to store state. */
+    localStorageKey?: string;
+    /** Session (tab-specific) storage key used to store state. */
+    sessionStorageKey?: string;
+    /** DashViewModel used to read / write view state. */
+    dashViewModel?: DashViewModel;
+    /** ViewManagerModel used to read / write view state. */
+    viewManagerModel?: ViewManagerModel;
+    /**
+     *  Function returning blob of data to be used for reading state.
+     *  Ignored if `prefKey`, `localStorageKey`, `dashViewModel` or 'viewManagerModel' are provided.
+     */
+    getData?: () => any;
+    /**
+     * Function to be used to write blob of data representing state.
+     * Ignored if `prefKey`, `localStorageKey`, `dashViewModel` or 'viewManagerModel' are provided.
+     */
+    setData?: (data: object) => void;
+}

package/build/types/core/persist/Persistable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Interface for objects that can be bound to a {@link PersistenceProvider}.
+ * @typeParam S - must be serializable to JSON and PersistableState<S> must be observable
+ */
+export interface Persistable<S> {
+    getPersistableState(): PersistableState<S>;
+    setPersistableState(state: PersistableState<S>): void;
+}
+/** Wrapper for a serializable Persistable state object. */
+export declare class PersistableState<S> {
+    value: S;
+    constructor(value: S);
+    equals(other: PersistableState<S>): boolean;
+}

package/build/types/core/persist/PersistenceProvider.d.ts

@@ -0,0 +1,69 @@
+import { DebounceSpec, HoistBase, Persistable, PersistableState } from '../';
+import { PersistOptions } from './';
+export type PersistenceProviderConfig<S = any> = {
+    persistOptions: PersistOptions;
+    target: Persistable<S>;
+    owner?: HoistBase;
+};
+/**
+ * Abstract superclass for adaptor objects used by models and components to (re)store state to and
+ * from a persistent location, typically a Hoist preference or key within browser local storage.
+ *
+ * Note that multiple instances of this object may be writing into the same location.
+ * Implementations should take care to incorporate any writes immediately into the readable state.
+ *
+ * Hoist-provided implementations include:
+ *   - {@link PrefProvider} - persists to a predefined Hoist JSON Preference.
+ *   - {@link LocalStorageProvider} - persists to browser local storage under a configured key.
+ *   - {@link DashViewProvider} - persists to a bound `DashViewModel` to save state for components
+ *     used within a dashboard widget. For this to be useful, the parent {@link DashModel} must
+ *     itself be persisted via a different provider - it acts as a collector of the widget-level
+ *     state managed by its DashViewModels and this provider.
+ *   - {@link ViewManagerProvider} - persists to saved views managed by {@link ViewManagerModel}.
+ *   - {@link CustomProvider} - API for app and components to provide their own storage mechanism.
+ */
+export declare abstract class PersistenceProvider<S = any> {
+    readonly path: string;
+    readonly debounce: DebounceSpec;
+    readonly owner: HoistBase;
+    readonly settleTime: number;
+    protected target: Persistable<S>;
+    protected defaultState: PersistableState<S>;
+    private disposer;
+    private lastReadState;
+    private lastReadTime;
+    /**
+     * Construct an instance of this class.
+     *
+     * Will fail gently, returning `null` and logging an error if the provider could not be created
+     * due to an unparseable config or failure on initial read.
+     *
+     * Note: Targets should initialize their default persistable state *before* creating a
+     * `PersistenceProvider` and defer creating reactions to persistable state until *after*. This
+     * allows the provider to capture the default state and then apply any persisted state to the
+     * target without thrashing.
+     */
+    static create<S>(cfg: PersistenceProviderConfig<S>): PersistenceProvider<S>;
+    /**
+     * Merge PersistOptions, respecting provider types, with later options overriding earlier ones.
+     */
+    static mergePersistOptions(defaults: PersistOptions, ...overrides: PersistOptions[]): PersistOptions;
+    /** Read persisted state at this provider's path. */
+    read(): PersistableState<S>;
+    /** Persist JSON-serializable state to this provider's path. */
+    write(state: S): void;
+    /** Clear any persisted data at a path. Also clears any parent objects that become empty. */
+    clear(): void;
+    destroy(): void;
+    /** Push the current state of this provider to its target. */
+    pushStateToTarget(): void;
+    /** Called by implementations only. Use the {@link create} factory instead. */
+    protected constructor(cfg: PersistenceProviderConfig<S>);
+    /** Called by factory method to bind this provider to its target. */
+    protected bindToTarget(target: Persistable<S>): void;
+    protected writeInternal(data: S): void;
+    protected writeRaw(obj: Record<typeof this.path, S>): void;
+    protected readRaw(): Record<typeof this.path, S>;
+    private static parseProviderClass;
+    private ensureValid;
+}

package/build/types/core/persist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Persistable';
+export * from './PersistOptions';
+export * from './PersistenceProvider';
+export * from './provider/LocalStorageProvider';
+export * from './provider/SessionStorageProvider';
+export * from './provider/DashViewProvider';
+export * from './provider/PrefProvider';
+export * from './provider/CustomProvider';
+export * from './provider/ViewManagerProvider';

package/build/types/core/persist/provider/CustomProvider.d.ts

@@ -0,0 +1,15 @@
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+/**
+ * A minimal Persistence provider for use by apps that wish to implement the actual persistence
+ * of the backing data via custom handlers.
+ *
+ * This provider allows applications to use the Persistence API to populate and read state from
+ * components without actually writing to any pre-defined storage.
+ */
+export declare class CustomProvider<S> extends PersistenceProvider<S> {
+    readonly getData: any;
+    readonly setData: any;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): any;
+    writeRaw(data: any): void;
+}

package/build/types/core/persist/provider/DashViewProvider.d.ts

@@ -0,0 +1,12 @@
+import type { DashViewModel } from '@xh/hoist/desktop/cmp/dash';
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+/**
+ * PersistenceProvider that stores state within a DashViewModel.
+ */
+export declare class DashViewProvider<S> extends PersistenceProvider<S> {
+    readonly dashViewModel: DashViewModel;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): import("../..").PlainObject;
+    writeRaw(data: any): void;
+    destroy(): void;
+}

package/build/types/core/persist/provider/LocalStorageProvider.d.ts

@@ -0,0 +1,10 @@
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+/**
+ * PersistenceProvider that stores state within the Browser's LocalStorage.
+ */
+export declare class LocalStorageProvider<S> extends PersistenceProvider<S> {
+    readonly key: string;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): any;
+    writeRaw(data: any): void;
+}

package/build/types/core/persist/provider/PrefProvider.d.ts

@@ -0,0 +1,10 @@
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+/**
+ * PersistenceProvider that stores state within the Hoist Preferences system.
+ */
+export declare class PrefProvider<S> extends PersistenceProvider<S> {
+    readonly key: string;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): any;
+    writeRaw(data: any): void;
+}

package/build/types/core/persist/provider/SessionStorageProvider.d.ts

@@ -0,0 +1,10 @@
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+/**
+ * PersistenceProvider that stores state within the Browser's SessionStorage.
+ */
+export declare class SessionStorageProvider<S> extends PersistenceProvider<S> {
+    readonly key: string;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): any;
+    writeRaw(data: any): void;
+}

package/build/types/core/persist/provider/ViewManagerProvider.d.ts

@@ -0,0 +1,9 @@
+import { PersistenceProvider, PersistenceProviderConfig } from '../PersistenceProvider';
+import type { ViewManagerModel } from '@xh/hoist/cmp/viewmanager/ViewManagerModel';
+export declare class ViewManagerProvider<S> extends PersistenceProvider<S> {
+    readonly viewManagerModel: ViewManagerModel;
+    constructor(cfg: PersistenceProviderConfig<S>);
+    readRaw(): Partial<import("../..").PlainObject>;
+    writeRaw(data: Record<typeof this.path, S>): void;
+    destroy(): void;
+}

package/build/types/core/types/AppState.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Enumeration of possible App States
+ */
+export declare const AppState: Readonly<{
+    PRE_AUTH: "PRE_AUTH";
+    AUTHENTICATING: "AUTHENTICATING";
+    LOGIN_REQUIRED: "LOGIN_REQUIRED";
+    INITIALIZING_HOIST: "INITIALIZING_HOIST";
+    INITIALIZING_APP: "INITIALIZING_APP";
+    RUNNING: "RUNNING";
+    SUSPENDED: "SUSPENDED";
+    LOAD_FAILED: "LOAD_FAILED";
+    ACCESS_DENIED: "ACCESS_DENIED";
+}>;
+export type AppState = (typeof AppState)[keyof typeof AppState];
+export interface AppSuspendData {
+    reason: 'IDLE' | 'SERVER_FORCE' | 'APP_UPDATE' | 'AUTH_EXPIRED';
+    message?: string;
+    exception?: unknown;
+}

package/build/types/core/types/Interfaces.d.ts

@@ -0,0 +1,303 @@
+import { RuleLike } from '@xh/hoist/data';
+import { MouseEvent, ReactElement, ReactNode } from 'react';
+import { LoadSpec, LoadSpecConfig } from '../load';
+import { Intent, PlainObject, Thunkable } from './Types';
+/**
+ * A user of the application, as loaded from the server.
+ *
+ * Note that instances of this class may contain other custom properties serialize by an
+ * application.  Applications may wish to extend this interface
+ */
+export interface HoistUser {
+    username: string;
+    email: string;
+    displayName: string;
+    roles: string[];
+    isHoistAdmin: boolean;
+    isHoistAdminReader: boolean;
+    isHoistRoleManager: boolean;
+    hasRole(s: string): boolean;
+    hasGate(s: string): boolean;
+}
+/**
+ * Identity of the authenticated user using the application,
+ * along with any user being impersonated.
+ */
+export interface IdentityInfo {
+    /**
+     * Actual underlying user that has authenticated in the app.
+     */
+    authUser: HoistUser;
+    /**
+     * User the app should be displayed for.  Typically the same as authUser, but
+     * will be different during impersonation.
+     */
+    apparentUser: HoistUser;
+}
+/**
+ * Options governing XH.reloadApp().
+ */
+export interface ReloadAppOptions {
+    /** Relative path to reload (e.g. 'mobile/').  Defaults to the existing location pathname. */
+    path?: string;
+    /** Should the query parameters be removed from the url before reload.  Default false. */
+    removeQueryParams?: boolean;
+}
+/**
+ * Options for showing a "toast" notification that appears and then automatically dismisses.
+ */
+export interface ToastSpec {
+    message: ReactNode;
+    icon?: ReactElement;
+    intent?: Intent;
+    /**
+     * Time in ms to show before auto-dismissing the toast, or null to keep toast
+     * visible until manually dismissed.  Default 3000.
+     */
+    timeout?: number;
+    /**
+     * If provided, will render a button within the toast to enable the user to take some
+     * specific action right from the toast.
+     */
+    actionButtonProps?: any;
+    /**
+     * Relative position at which to display toast, e.g. "bottom-right" (default) or "top".
+     * (Desktop only.)
+     */
+    position?: string;
+    /**
+     * DOM element relative to which the toast should be positioned. If null, Toast will show
+     * along edge of overall document. (Desktop only.)
+     */
+    containerRef?: HTMLElement;
+}
+/**
+ * Options for showing a modal alert, confirm, or prompt.
+ */
+export interface MessageSpec {
+    message?: ReactNode;
+    title?: string;
+    icon?: ReactElement;
+    className?: string;
+    /**
+     * Unique key identifying the message. If subsequent messages.
+     * If subsequent messages are triggered with this key, they will replace this message.
+     * Useful for usages that may be producing messages recursively, or via timers and wish to
+     * avoid generating a large stack of duplicates.
+     */
+    messageKey?: string;
+    /** Config for input to be displayed (as a prompt). */
+    input?: MessageSpecInput;
+    /** If specified, user will be required to type this text when confirming. */
+    extraConfirmText?: string;
+    /**
+     * Text/label to inform the user of the text required to confirm.
+     * Only used if extraConfirmText is specified.
+     * Defaults to `Type '${extraConfirmText}' to confirm:`.
+     */
+    extraConfirmLabel?: ReactNode;
+    /**
+     * Props for primary confirm button.
+     * Must provide either text or icon for button to be displayed, or use a preconfigured
+     * helper such as `XH.alert()` or `XH.confirm()` for default buttons.
+     */
+    confirmProps?: any;
+    /**
+     * Props for secondary cancel button.
+     * Must provide either text or icon for button to be displayed, or use a preconfigured
+     * helper such as `XH.alert()` or `XH.confirm()` for default buttons.
+     */
+    cancelProps?: any;
+    /**
+     * Specify 'left' to place the Cancel button (if shown) on the
+     * left edge of the dialog toolbar, with a filler between it and Confirm.
+     */
+    cancelAlign?: any;
+    /** Callback to execute when confirm is clicked.*/
+    onConfirm?(): any;
+    /** Callback to execute when cancel is clicked.*/
+    onCancel?(): any;
+    /** Flag to specify whether a popup can be clicked out of or escaped.*/
+    dismissable?: boolean;
+    /** Flag to specify whether onCancel is executed when clicking out of or escaping a popup. */
+    cancelOnDismiss?: boolean;
+}
+export interface MessageSpecInput {
+    /** An element specifying a HoistInput, defaults to a platform appropriate TextInput. */
+    item?: ReactElement;
+    /** Validation constraints to apply. */
+    rules?: RuleLike[];
+    /** Initial value for the input. */
+    initialValue?: any;
+}
+/**
+ * Configuration object for an app-wide banner.
+ */
+export interface BannerSpec {
+    message?: ReactNode;
+    icon?: ReactElement;
+    intent?: Intent;
+    className?: string;
+    /**
+     * Determines order in which banner will be displayed.
+     * If not provided, banner will be placed below any existing banners.
+     * @see BannerModel.BANNER_SORTS
+     */
+    sortOrder?: number;
+    /**
+     * Showing a banner with a given category will hide any
+     * preexisting banner with the same category.
+     */
+    category?: string;
+    /**
+     *  Callback function triggered when the user clicks the close button.
+     *  (Note, banners closed via `XH.hideBanner()` or when the max
+     *  number of banners shown is exceeded will NOT trigger this callback.)
+     */
+    onClose?(model: any): any;
+    /**
+     * Callback function triggered when the user clicks on the banner.
+     */
+    onClick?(model: any): any;
+    /**
+     *  If provided, will render a button within the banner to enable the user to
+     *  take some specific action right from the banner.
+     */
+    actionButtonProps?: object;
+    /** Enable the Banner to be closed? Defaults to true. */
+    enableClose?: boolean;
+}
+/**
+ * Option for Application option in the application.
+ */
+export interface AppOptionSpec {
+    name: string;
+    prefName?: string;
+    /** Config for FormField for this option. */
+    formField: any;
+    /** Config for FieldModel for the option.*/
+    fieldModel?: any;
+    /** Function, possibly async, which returns the value. */
+    valueGetter?: () => any;
+    /** Function, possibly async, which sets the value. */
+    valueSetter?: (s: any) => any;
+    /** True to reload the app after changing this option.  Default false. */
+    reloadRequired?: boolean;
+    /** Optional flag to omit displaying option. */
+    omit?: Thunkable<boolean>;
+}
+/**
+ * Severity levels for tracking.  Default is 'INFO'.
+ */
+export type TrackSeverity = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+/**
+ * Options for tracking activity on the server via TrackService.
+ */
+export interface TrackOptions {
+    /** Short description of the activity being tracked. */
+    message: string;
+    /** App-supplied category.*/
+    category?: string;
+    /** Correlation ID to save along with track log. */
+    correlationId?: string;
+    /** App-supplied data to save along with track log.*/
+    data?: PlainObject | Array<unknown>;
+    /**
+     * Set true to log on the server all primitive values in the 'data' property.
+     * May also be specified as list of specific property keys that should be logged.
+     *
+     * Default value for this property may be set in xhActivityTrackingConfig.
+     * If no default set, value will be `false` and nothing in data will be logged.
+     */
+    logData?: boolean | string[];
+    /**
+     * Flag to indicate relative importance of activity. Default 'INFO'.
+     *
+     * Allows conditional saving of messages depending on the currently active
+     * level configuration for the category/user.  See HoistCore's 'TrackService' for
+     * more information.
+     *
+     * Note, errors should be tracked via {@link XH.handleException}, which
+     * will post to the server for dedicated logging if requested.
+     */
+    severity?: TrackSeverity;
+    /**
+     * Set to true to log this message only once during the current session. The category and
+     * message text will be used as a compound key to identify repeated messages.
+     */
+    oncePerSession?: boolean;
+    /** Optional LoadSpec associated with this track.*/
+    loadSpec?: LoadSpec | LoadSpecConfig;
+    /** Timestamp for action. */
+    timestamp?: number;
+    /** Elapsed time (ms) for action. */
+    elapsed?: number;
+    /** Optional flag to omit sending message. */
+    omit?: Thunkable<boolean>;
+}
+/**
+ * The base `MenuToken` type.  '-' is interpreted as the standard textless divider.
+ * Components will likely extend this type to support other strings like 'copyToClipboard',
+ * 'print', etc. which the component then converts into a {@link MenuItem}.
+ */
+export type MenuToken = '-';
+/**
+ * `MenuContext` is the set of contextual arguments passed to a {@link MenuItem}'s
+ * `actionFn` and `prepareFn`. `contextMenuEvent` is the right click event that opened the
+ * context menu.  It is optional because the `contextMenu` component can also be used on
+ * popover buttons, where there is no `contextMenuEvent`.
+ *
+ * Components offering a built-in {@link contextMenu} can extend `MenuContext` to add values
+ * relevant to the component.  See for example {@link ChartMenuContext}.
+ */
+export interface MenuContext {
+    contextMenuEvent?: MouseEvent | PointerEvent;
+}
+/**
+ * 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<T = MenuToken, C = MenuContext> = MenuItemLike<T, C>[] | ((e: MouseEvent | PointerEvent, context: C) => MenuItemLike<T, C>[]) | boolean;
+/**
+ *  Basic interface for a MenuItem to appear in a menu.
+ *
+ *  MenuItems can be displayed within a context menu, or shown when clicking on a button.
+ */
+export interface MenuItem<T = MenuToken, C = MenuContext> {
+    /** Label to be displayed. */
+    text: ReactNode;
+    /** Icon to be displayed. */
+    icon?: ReactElement;
+    /** Intent to be used for rendering the menu item. */
+    intent?: Intent;
+    /** Css class name to be added when rendering the menu item. */
+    className?: string;
+    /** Executed when the user clicks the menu item. */
+    actionFn?: (e: MouseEvent | PointerEvent, context?: C) => void;
+    /** Executed before the item is shown.  Use to adjust properties dynamically. */
+    prepareFn?: (me: MenuItem<T, C>, context?: C) => void;
+    /** Child menu items. */
+    items?: MenuItemLike<T, C>[];
+    /** True to disable this item. */
+    disabled?: boolean;
+    /** True to hide this item. May be set dynamically via prepareFn. */
+    hidden?: boolean;
+    /** True to skip this item. May be set dynamically via prepareFn. Alias for hidden.  */
+    omit?: Thunkable<boolean>;
+}
+/**
+ * An item that can exist in a Menu.
+ * Components may accept token strings, in addition, '-' will be interpreted as the standard
+ * textless divider that will also be de-duped if appearing at the beginning, or end, or adjacent
+ * to another divider at render time. Also allows for a ReactNode for flexible display.
+ */
+export type MenuItemLike<T = MenuToken, C = MenuContext> = MenuItem<T, C> | T | ReactElement;
+export declare function isMenuItem<T, C>(item: MenuItemLike<T, C>): item is MenuItem<T, C>;
+/**
+ * An option to be passed to Select controls
+ */
+export interface SelectOption {
+    value?: any;
+    label?: string;
+    options?: (SelectOption | any)[];
+}