@xh/hoist 57.0.0 → 57.0.2

package/build/types/desktop/cmp/appOption/ThemeAppOption.d.ts

@@ -0,0 +1,340 @@
+/// <reference types="react" />
+import { ButtonGroupInputProps } from '@xh/hoist/desktop/cmp/input';
+import { FormFieldProps } from '@xh/hoist/desktop/cmp/form';
+import '@xh/hoist/desktop/register';
+interface ThemeAppOptionSpec {
+    /** Props for nested FormField */
+    formFieldProps?: FormFieldProps;
+    /** Props for nested ButtonGroupInput */
+    inputProps?: ButtonGroupInputProps;
+}
+/**
+ * Convenience configuration for the `theme` AppOption.
+ */
+export declare const themeAppOption: ({ formFieldProps, inputProps }?: ThemeAppOptionSpec) => {
+    name: string;
+    formField: {
+        clickableLabel?: boolean;
+        inline?: boolean;
+        labelTextAlign?: import("@xh/hoist/core").HSide;
+        labelWidth?: number;
+        leftErrorIcon?: boolean;
+        minimal?: boolean;
+        tooltipBoundary?: import("popper.js").default.Boundary;
+        tooltipPosition?: import("@blueprintjs/core").PopoverPosition;
+        commitOnChange?: boolean;
+        disabled?: boolean;
+        field: string;
+        info?: import("react").ReactNode;
+        label: import("react").ReactNode;
+        readonlyRenderer?: (v: any) => import("react").ReactNode;
+        requiredIndicator?: string;
+        model?: import("../../../cmp/form").FieldModel;
+        modelConfig?: unknown;
+        modelRef?: import("react").Ref<import("../../../cmp/form").FieldModel>;
+        className?: string;
+        children?: import("react").ReactNode;
+        margin?: string | number;
+        marginTop?: string | number;
+        marginRight?: string | number;
+        marginBottom?: string | number;
+        marginLeft?: string | number;
+        padding?: string | number;
+        paddingTop?: string | number;
+        paddingRight?: string | number;
+        paddingBottom?: string | number;
+        paddingLeft?: string | number;
+        height?: string | number;
+        minHeight?: string | number;
+        maxHeight?: string | number;
+        width?: string | number;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+        flex?: string | number;
+        flexBasis?: string | number;
+        flexDirection?: string | number;
+        flexGrow?: string | number;
+        flexShrink?: string | number;
+        flexWrap?: string | number;
+        alignItems?: string;
+        alignSelf?: string;
+        alignContent?: string;
+        justifyContent?: string;
+        overflow?: string;
+        overflowX?: string;
+        overflowY?: string;
+        textOverflow?: string;
+        top?: string | number;
+        left?: string | number;
+        position?: string;
+        display?: string;
+        onClick?: import("react").MouseEventHandler<HTMLDivElement>;
+        slot?: string;
+        style?: import("react").CSSProperties;
+        title?: string;
+        defaultChecked?: boolean;
+        defaultValue?: string | number | readonly string[];
+        suppressContentEditableWarning?: boolean;
+        suppressHydrationWarning?: boolean;
+        accessKey?: string;
+        autoFocus?: boolean;
+        contentEditable?: (boolean | "true" | "false") | "inherit";
+        dir?: string;
+        draggable?: boolean | "true" | "false";
+        hidden?: boolean;
+        id?: string;
+        lang?: string;
+        nonce?: string;
+        placeholder?: string;
+        spellCheck?: boolean | "true" | "false";
+        tabIndex?: number;
+        translate?: "yes" | "no";
+        radioGroup?: string;
+        role?: import("react").AriaRole;
+        about?: string;
+        content?: string;
+        datatype?: string;
+        inlist?: any;
+        prefix?: string;
+        property?: string;
+        rel?: string;
+        resource?: string;
+        rev?: string;
+        typeof?: string;
+        vocab?: string;
+        autoCapitalize?: string;
+        autoCorrect?: string;
+        autoSave?: string;
+        color?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        itemID?: string;
+        itemRef?: string;
+        results?: number;
+        security?: string;
+        unselectable?: "on" | "off";
+        inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+        is?: string;
+        'aria-activedescendant'?: string;
+        'aria-atomic'?: boolean | "true" | "false";
+        'aria-autocomplete'?: "list" | "none" | "inline" | "both";
+        'aria-braillelabel'?: string;
+        'aria-brailleroledescription'?: string;
+        'aria-busy'?: boolean | "true" | "false";
+        'aria-checked'?: boolean | "true" | "false" | "mixed";
+        'aria-colcount'?: number;
+        'aria-colindex'?: number;
+        'aria-colindextext'?: string;
+        'aria-colspan'?: number;
+        'aria-controls'?: string;
+        'aria-current'?: boolean | "date" | "time" | "true" | "false" | "page" | "step" | "location";
+        'aria-describedby'?: string;
+        'aria-description'?: string;
+        'aria-details'?: string;
+        'aria-disabled'?: boolean | "true" | "false";
+        'aria-dropeffect'?: "link" | "none" | "copy" | "execute" | "move" | "popup";
+        'aria-errormessage'?: string;
+        'aria-expanded'?: boolean | "true" | "false";
+        'aria-flowto'?: string;
+        'aria-grabbed'?: boolean | "true" | "false";
+        'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+        'aria-hidden'?: boolean | "true" | "false";
+        'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
+        'aria-keyshortcuts'?: string;
+        'aria-label'?: string;
+        'aria-labelledby'?: string;
+        'aria-level'?: number;
+        'aria-live'?: "off" | "assertive" | "polite";
+        'aria-modal'?: boolean | "true" | "false";
+        'aria-multiline'?: boolean | "true" | "false";
+        'aria-multiselectable'?: boolean | "true" | "false";
+        'aria-orientation'?: "horizontal" | "vertical";
+        'aria-owns'?: string;
+        'aria-placeholder'?: string;
+        'aria-posinset'?: number;
+        'aria-pressed'?: boolean | "true" | "false" | "mixed";
+        'aria-readonly'?: boolean | "true" | "false";
+        'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+        'aria-required'?: boolean | "true" | "false";
+        'aria-roledescription'?: string;
+        'aria-rowcount'?: number;
+        'aria-rowindex'?: number;
+        'aria-rowindextext'?: string;
+        'aria-rowspan'?: number;
+        'aria-selected'?: boolean | "true" | "false";
+        'aria-setsize'?: number;
+        'aria-sort'?: "none" | "ascending" | "descending" | "other";
+        'aria-valuemax'?: number;
+        'aria-valuemin'?: number;
+        'aria-valuenow'?: number;
+        'aria-valuetext'?: string;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        };
+        onCopy?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onCut?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onPaste?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement>;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement>;
+        onFocus?: import("react").FocusEventHandler<HTMLDivElement>;
+        onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement>;
+        onBlur?: import("react").FocusEventHandler<HTMLDivElement>;
+        onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement>;
+        onChangeCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onBeforeInput?: import("react").FormEventHandler<HTMLDivElement>;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onInput?: import("react").FormEventHandler<HTMLDivElement>;
+        onInputCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onReset?: import("react").FormEventHandler<HTMLDivElement>;
+        onResetCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onSubmit?: import("react").FormEventHandler<HTMLDivElement>;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onInvalid?: import("react").FormEventHandler<HTMLDivElement>;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement>;
+        onLoad?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onError?: import("react").ReactEventHandler<HTMLDivElement>;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement>;
+        onAbort?: import("react").ReactEventHandler<HTMLDivElement>;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onCanPlay?: import("react").ReactEventHandler<HTMLDivElement>;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement>;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onDurationChange?: import("react").ReactEventHandler<HTMLDivElement>;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEmptied?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEncrypted?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEnded?: import("react").ReactEventHandler<HTMLDivElement>;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadedData?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadStart?: import("react").ReactEventHandler<HTMLDivElement>;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPause?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPlay?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPlaying?: import("react").ReactEventHandler<HTMLDivElement>;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onProgress?: import("react").ReactEventHandler<HTMLDivElement>;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onRateChange?: import("react").ReactEventHandler<HTMLDivElement>;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onResize?: import("react").ReactEventHandler<HTMLDivElement>;
+        onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSeeked?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSeeking?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onStalled?: import("react").ReactEventHandler<HTMLDivElement>;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSuspend?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement>;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement>;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onWaiting?: import("react").ReactEventHandler<HTMLDivElement>;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onAuxClick?: import("react").MouseEventHandler<HTMLDivElement>;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onContextMenu?: import("react").MouseEventHandler<HTMLDivElement>;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement>;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onDrag?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragEnd?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragEnter?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragExit?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragLeave?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragOver?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragStart?: import("react").DragEventHandler<HTMLDivElement>;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onDrop?: import("react").DragEventHandler<HTMLDivElement>;
+        onDropCapture?: import("react").DragEventHandler<HTMLDivElement>;
+        onMouseDown?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseMove?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseOut?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseOver?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseUp?: import("react").MouseEventHandler<HTMLDivElement>;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement>;
+        onSelect?: import("react").ReactEventHandler<HTMLDivElement>;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement>;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchMove?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchStart?: import("react").TouchEventHandler<HTMLDivElement>;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement>;
+        onPointerDown?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerMove?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerUp?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerOver?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerOut?: import("react").PointerEventHandler<HTMLDivElement>;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement>;
+        onScroll?: import("react").UIEventHandler<HTMLDivElement>;
+        onScrollCapture?: import("react").UIEventHandler<HTMLDivElement>;
+        onWheel?: import("react").WheelEventHandler<HTMLDivElement>;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement>;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement>;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement>;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement>;
+        item: import("react").ReactElement<ButtonGroupInputProps, any>;
+    };
+    prefName: string;
+    valueSetter: (v: any) => void;
+};
+export {};

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

@@ -0,0 +1,3 @@
+export * from './AutoRefreshAppOption';
+export * from './SizingModeAppOption';
+export * from './ThemeAppOption';

package/build/types/desktop/cmp/appbar/AppBar.d.ts

@@ -0,0 +1,34 @@
+import { HoistProps, HSide } from '@xh/hoist/core';
+import { AppMenuButtonProps } from '@xh/hoist/desktop/cmp/button';
+import '@xh/hoist/desktop/register';
+import { ReactNode, ReactElement } from 'react';
+import './AppBar.scss';
+export interface AppBarProps extends HoistProps {
+    /** Position of the AppMenuButton. */
+    appMenuButtonPosition?: HSide;
+    /** Allows overriding the default properties of the App Menu button. @see AppMenuButton */
+    appMenuButtonProps?: AppMenuButtonProps;
+    /** True to hide the AppMenuButton. */
+    hideAppMenuButton?: boolean;
+    /** True to hide the Refresh button. */
+    hideRefreshButton?: boolean;
+    /** True to hide the "What's New?" button, even if an unread changelog entry is available. */
+    hideWhatsNewButton?: boolean;
+    /** Icon to display to the left of the title. */
+    icon?: ReactElement;
+    /** Items to be added to the left side of the AppBar, immediately after the title. */
+    leftItems?: ReactNode[];
+    /** Items to be added to the right side of the AppBar, before the standard buttons. */
+    rightItems?: ReactNode[];
+    /** Title to display to the left side of the AppBar. Defaults to XH.clientAppName. */
+    title?: ReactNode;
+}
+/**
+ * A standard application navigation bar which displays the application name and a standard set of
+ * buttons for common application actions. Application specific items can be displayed on the left
+ * or right sides of the AppBar.
+ *
+ * The standard buttons which are visible will be based on user roles and application configuration,
+ * or they can each be explicitly hidden.
+ */
+export declare const AppBar: import("react").FC<AppBarProps>, appBar: import("@xh/hoist/core").ElementFactory<AppBarProps>;

package/build/types/desktop/cmp/appbar/AppBarSeparator.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+/**
+ * Convenience component for adding a separator between AppBar items.
+ */
+export declare const AppBarSeparator: import("react").FC<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>, appBarSeparator: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

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

@@ -0,0 +1,2 @@
+export * from './AppBar';
+export * from './AppBarSeparator';

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

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import { MenuItemLike } from '@xh/hoist/core';
+import { ButtonProps } from '@xh/hoist/desktop/cmp/button';
+import '@xh/hoist/desktop/register';
+export interface AppMenuButtonProps extends ButtonProps {
+    /**
+     * Array of extra menu items. Can contain:
+     *  + `MenuItems` or configs to create them.
+     *  + `MenuDividers` or the special string token '-'.
+     *  + React Elements or strings, which will be interpreted as the `text` property for a MenuItem.
+     */
+    extraItems?: MenuItemLike[];
+    /** True to hide the About button */
+    hideAboutItem?: boolean;
+    /** True to hide the Admin Item. Always hidden for users w/o HOIST_ADMIN role. */
+    hideAdminItem?: boolean;
+    /**
+     * True to hide the Changelog (release notes) item.
+     * Always hidden when ChangelogService not enabled / populated.
+     */
+    hideChangelogItem?: boolean;
+    /** True to hide the Feedback Item. */
+    hideFeedbackItem?: boolean;
+    /**
+     * True to hide the Impersonate Item.
+     * Always hidden for users w/o HOIST_ADMIN role or if impersonation is disabled.
+     */
+    hideImpersonateItem?: boolean;
+    /** True to hide the Logout button. Defaulted to appSpec.isSSO. */
+    hideLogoutItem?: boolean;
+    /** True to hide the Options button. */
+    hideOptionsItem?: boolean;
+    /** True to hide the Theme Toggle button. */
+    hideThemeItem?: boolean;
+}
+export declare const AppMenuButton: import("react").FC<AppMenuButtonProps>, appMenuButton: import("@xh/hoist/core").ElementFactory<AppMenuButtonProps>;

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

@@ -0,0 +1,28 @@
+import { ButtonProps as BpButtonProps } from '@blueprintjs/core';
+import { HoistModel, HoistProps, LayoutProps, StyleProps, Intent } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ReactNode, ReactElement } from 'react';
+import './Button.scss';
+export interface ButtonProps<M extends HoistModel = null> extends HoistProps<M>, StyleProps, LayoutProps, BpButtonProps {
+    active?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    icon?: ReactElement;
+    intent?: Intent;
+    minimal?: boolean;
+    outlined?: boolean;
+    rightIcon?: ReactElement;
+    text?: ReactNode;
+    title?: string;
+    value?: any;
+    tabIndex?: number;
+    /** Alias for title. */
+    tooltip?: string;
+}
+/**
+ * Wrapper around Blueprint's Button component. Defaults to the `minimal` style for reduced chrome
+ * and adds layout support for top-level sizing and margin/padding props.
+ *
+ * Relays all other props supported by Blueprint's button.
+ */
+export declare const Button: import("react").FC<ButtonProps<null>>, button: import("@xh/hoist/core").ElementFactory<ButtonProps<null>>;

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

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { SetOptional } from 'type-fest';
+import { ButtonGroupProps as BpButtonGroupProps } from '@blueprintjs/core';
+import { HoistModel, HoistProps, LayoutProps, StyleProps } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+export interface ButtonGroupProps<M extends HoistModel = null> extends HoistProps<M>, LayoutProps, StyleProps, SetOptional<BpButtonGroupProps, 'children'> {
+    /** True to have all buttons fill available width equally. */
+    fill?: boolean;
+    /** True to render each button with minimal surrounding chrome (default false). */
+    minimal?: boolean;
+    /** True to render in a vertical orientation. */
+    vertical?: boolean;
+}
+/**
+ * Wrapper around Blueprint's ButtonGroup component, with LayoutSupport.
+ */
+export declare const ButtonGroup: import("react").FC<ButtonGroupProps<null>>, buttonGroup: import("@xh/hoist/core").ElementFactory<ButtonGroupProps<null>>;

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { GridModel, GridAutosizeOptions } from '@xh/hoist/cmp/grid';
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export interface ColAutosizeButtonProps extends ButtonProps {
+    /** GridModel of the grid for which this button should autosize columns. */
+    gridModel?: GridModel;
+    /** Options for the grid autosize. */
+    autosizeOptions?: GridAutosizeOptions;
+}
+/**
+ * A convenience button to autosize visible Grid columns.
+ */
+export declare const ColAutosizeButton: import("react").FC<ColAutosizeButtonProps>, colAutosizeButton: import("@xh/hoist/core").ElementFactory<ColAutosizeButtonProps>;

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { GridModel } from '@xh/hoist/cmp/grid';
+import '@xh/hoist/desktop/register';
+import { Position } from '@xh/hoist/kit/blueprint';
+import { ButtonProps } from './Button';
+export interface ColChooserButtonProps extends ButtonProps {
+    /** GridModel of the grid for which this button should show a chooser. */
+    gridModel?: GridModel;
+    /** Position for chooser popover, as per Blueprint docs. */
+    popoverPosition?: Position;
+}
+/**
+ * A convenience button to trigger the display of a ColChooser for user selection and discovery of
+ * available Grid columns. For use by applications when a button is desired in addition to the
+ * context menu item built into the Grid component directly.
+ *
+ * Requires the `GridModel.colChooserModel` config option. Set to true for default implementation.
+ */
+export declare const ColChooserButton: import("react").FC<ColChooserButtonProps>, colChooserButton: import("@xh/hoist/core").ElementFactory<ColChooserButtonProps>;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { DashCanvasModel } from '@xh/hoist/desktop/cmp/dash';
+import { ButtonProps } from './Button';
+export interface DashCanvasAddViewButtonProps extends ButtonProps {
+    /** DashCanvasModel for which this button should allow the user to add views. */
+    dashCanvasModel?: DashCanvasModel;
+}
+/**
+ * A convenience menu button to add views to a DashCanvas.
+ */
+export declare const DashCanvasAddViewButton: import("react").FC<DashCanvasAddViewButtonProps>, dashCanvasAddViewButton: import("@xh/hoist/core").ElementFactory<DashCanvasAddViewButtonProps>;

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

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { GridModel } from '@xh/hoist/cmp/grid';
+import '@xh/hoist/desktop/register';
+import { ExportOptions } from '@xh/hoist/svc';
+import { ButtonProps } from './Button';
+export interface ExportButtonProps extends ButtonProps {
+    gridModel?: GridModel;
+    exportOptions?: ExportOptions;
+}
+/**
+ * Convenience Button preconfigured for use as a trigger for an export/download of data.
+ *
+ * Must be provided either an onClick handler *or* a gridModel.  GridModel may be provided
+ * in props, or otherwise will be looked up by this model from context.
+ *
+ * If a gridModel is provided, this button will call exportAsync() on the model class.
+ * Options supported by GridExportService.exportAsync() can be set via the exportOptions
+ * props.
+ *
+ * Requires the `GridModel.enableExport` config option to be true.
+ */
+export declare const ExportButton: import("react").FC<ExportButtonProps>, exportButton: import("@xh/hoist/core").ElementFactory<ExportButtonProps>;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export type FeedbackButtonProps = ButtonProps;
+/**
+ * Convenience Button preconfigured for use as a trigger for the XH feedback dialog.
+ * Can be provided an onClick handler, otherwise will call default framework handler.
+ */
+export declare const FeedbackButton: import("react").FC<FeedbackButtonProps>, feedbackButton: import("@xh/hoist/core").ElementFactory<FeedbackButtonProps>;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/desktop/cmp/button';
+import '@xh/hoist/desktop/register';
+export type LaunchAdminButtonProps = ButtonProps;
+/**
+ * Convenience Button to open the admin client.
+ * Visible only to users with the hoistAdmin application role.
+ */
+export declare const LaunchAdminButton: import("react").FC<LaunchAdminButtonProps>, launchAdminButton: import("@xh/hoist/core").ElementFactory<LaunchAdminButtonProps>;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export type LogoutButtonProps = ButtonProps;
+/**
+ * Convenience Button preconfigured for use as a trigger for a logout operation.
+ *
+ * An onClick handler can be provided to implement additional operations on logout,
+ * but should ensure it calls `XH.identityService.logoutAsync()`.
+ */
+export declare const LogoutButton: import("react").FC<LogoutButtonProps>, logoutButton: import("@xh/hoist/core").ElementFactory<LogoutButtonProps>;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/desktop/cmp/button/Button';
+import { PanelModel } from '@xh/hoist/desktop/cmp/panel';
+import '@xh/hoist/desktop/register';
+export interface ModalToggleButtonProps extends ButtonProps {
+    panelModel?: PanelModel;
+}
+/**
+ * A convenience button to toggle a Panel's modal view state.
+ */
+export declare const ModalToggleButton: import("react").FC<ModalToggleButtonProps>, modalToggleButton: import("@xh/hoist/core").ElementFactory<ModalToggleButtonProps>;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export type OptionsButtonProps = ButtonProps;
+/**
+ * Convenience Button preconfigured for use as a trigger for opening the XH options dialog.
+ *
+ * Can be provided an onClick handler, otherwise will call default framework handler.
+ */
+export declare const OptionsButton: import("react").FC<OptionsButtonProps>, optionsButton: import("@xh/hoist/core").ElementFactory<OptionsButtonProps>;

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { HoistModel } from '@xh/hoist/core';
+import '@xh/hoist/desktop/register';
+import { ButtonProps } from './Button';
+export type RefreshButtonProps = ButtonProps<HoistModel>;
+/**
+ * Convenience Button preconfigured for use as a trigger for a refresh operation.
+ *
+ * If an onClick handler is provided it will be used. Otherwise this button will
+ * be linked to any model in props with LoadSupport enabled, or the contextual
+ * See {@link RefreshContextModel}.
+ */
+export declare const RefreshButton: import("react").FC<RefreshButtonProps>, refreshButton: import("@xh/hoist/core").ElementFactory<RefreshButtonProps>;

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

@@ -0,0 +1,16 @@
+import '@xh/hoist/desktop/register';
+import { ReactNode } from 'react';
+import { ButtonProps } from './Button';
+export interface RestoreDefaultsButtonProps extends ButtonProps {
+    /** Message for confirm dialog shown prior to clearing user customizations. */
+    warningMessage: ReactNode;
+    /** Title for confirm dialog shown prior to clearing user customizations. */
+    warningTitle: string;
+}
+/**
+ * Convenience Button preconfigured for use as a trigger for resetting user customizations.
+ * Clears all user preferences, all grid state saved to local storage, and then reloads the app.
+ *
+ * Can be provided an onClick handler, otherwise will call default framework handler.
+ */
+export declare const RestoreDefaultsButton: import("react").FC<RestoreDefaultsButtonProps>, restoreDefaultsButton: import("@xh/hoist/core").ElementFactory<RestoreDefaultsButtonProps>;