@xh/hoist 57.0.0 → 57.0.1

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

@@ -0,0 +1,333 @@
+/// <reference types="react" />
+import { ButtonGroupInputProps } from '@xh/hoist/mobile/cmp/input';
+import { FormFieldProps } from '@xh/hoist/mobile/cmp/form';
+import '@xh/hoist/mobile/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: {
+        commitOnChange?: boolean;
+        disabled?: boolean;
+        field: string;
+        info?: import("react").ReactNode;
+        label: import("react").ReactNode;
+        minimal?: boolean;
+        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/mobile/cmp/appOption/index.d.ts

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

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

@@ -0,0 +1,22 @@
+import { LayoutProps, StyleProps, HoistModel, HoistProps, Intent } from '@xh/hoist/core';
+import '@xh/hoist/mobile/register';
+import { ReactNode, ReactElement, MouseEvent } from 'react';
+import './Button.scss';
+export interface ButtonProps<M extends HoistModel = HoistModel> extends HoistProps<M>, LayoutProps, StyleProps {
+    active?: boolean;
+    disabled?: boolean;
+    icon?: ReactElement;
+    intent?: Intent;
+    minimal?: boolean;
+    onClick?: (e: MouseEvent) => void;
+    outlined?: boolean;
+    text?: ReactNode;
+    value?: any;
+    modifier?: string;
+    tabIndex?: number;
+}
+/**
+ * Wrapper around Onsen's Button component. Adds layout support for top-level sizing and
+ * margin/padding props. Relays all other props supported by Onsen's Button.
+ */
+export declare const Button: import("react").FC<ButtonProps<HoistModel>>, button: import("@xh/hoist/core").ElementFactory<ButtonProps<HoistModel>>;

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { BoxProps, HoistProps, Intent } from '@xh/hoist/core';
+import '@xh/hoist/mobile/register';
+import './ButtonGroup.scss';
+export interface ButtonGroupProps extends HoistProps, BoxProps {
+    intent?: Intent;
+    minimal?: boolean;
+    outlined?: boolean;
+}
+/**
+ * A segmented group of buttons. Should receive a list of Buttons as a children.
+ */
+export declare const ButtonGroup: import("react").FC<ButtonGroupProps>, buttonGroup: import("@xh/hoist/core").ElementFactory<ButtonGroupProps>;

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { GridModel, GridAutosizeOptions } from '@xh/hoist/cmp/grid';
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+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/mobile/cmp/button/ColChooserButton.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { GridModel } from '@xh/hoist/cmp/grid';
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+export interface ColChooserButtonProps extends ButtonProps {
+    /** GridModel of the grid for which this button should show a chooser. */
+    gridModel?: GridModel;
+}
+/**
+ * A convenience button to trigger the display of a ColChooser for user selection,
+ * discovery and reordering of available Grid columns.
+ *
+ * Requires a `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/mobile/cmp/button/ExpandCollapseButton.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { GridModel } from '@xh/hoist/cmp/grid';
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+export interface ExpandCollapseButtonProps extends ButtonProps {
+    /** GridModel of the grid for which this button should show a chooser. */
+    gridModel?: GridModel;
+}
+/**
+ * A convenience button to expand / collapse all rows in grouped or tree grid.
+ */
+export declare const ExpandCollapseButton: import("react").FC<ExpandCollapseButtonProps>, expandCollapseButton: import("@xh/hoist/core").ElementFactory<ExpandCollapseButtonProps>;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+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 use default action provided by framework.
+ */
+export declare const FeedbackButton: import("react").FC<FeedbackButtonProps>, feedbackButton: import("@xh/hoist/core").ElementFactory<FeedbackButtonProps>;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+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/mobile/cmp/button/NavigatorBackButton.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+export type NavigatorBackButtonProps = ButtonProps;
+/**
+ * Convenience Button preconfigured to use navigate back one page.
+ */
+export declare const NavigatorBackButton: import("react").FC<NavigatorBackButtonProps>, navigatorBackButton: import("@xh/hoist/core").ElementFactory<NavigatorBackButtonProps>;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+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 use default action provided by framework.
+ */
+export declare const OptionsButton: import("react").FC<OptionsButtonProps>, optionsButton: import("@xh/hoist/core").ElementFactory<OptionsButtonProps>;

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { HoistModel } from '@xh/hoist/core';
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+export type RefreshButtonProps = ButtonProps<HoistModel>;
+/**
+ * Convenience Button preconfigured for use as a trigger for a refresh operation.
+ *
+ * If a model is provided it will be directly refreshed.  Alternatively an onClick handler
+ * may be provided.  If neither of these props are provided, the contextual RefreshContextModel
+ * for this button will be used.
+ */
+export declare const RefreshButton: import("react").FC<RefreshButtonProps>, refreshButton: import("@xh/hoist/core").ElementFactory<RefreshButtonProps>;

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

@@ -0,0 +1,16 @@
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+import { ReactNode } from 'react';
+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>;

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+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/mobile/cmp/button/index.d.ts

@@ -0,0 +1,11 @@
+export * from './Button';
+export * from './ButtonGroup';
+export * from './ColAutosizeButton';
+export * from './ColChooserButton';
+export * from './ExpandCollapseButton';
+export * from './FeedbackButton';
+export * from './ThemeToggleButton';
+export * from './LogoutButton';
+export * from './RefreshButton';
+export * from './RestoreDefaultsButton';
+export * from './NavigatorBackButton';

package/build/types/mobile/cmp/dialog/Dialog.d.ts

@@ -0,0 +1,17 @@
+import { HoistProps } from '@xh/hoist/core';
+import '@xh/hoist/mobile/register';
+import { ReactElement, ReactNode } from 'react';
+import './Dialog.scss';
+export interface DialogProps extends HoistProps {
+    isOpen?: boolean;
+    isCancelable?: boolean;
+    onCancel?: () => void;
+    icon?: ReactElement;
+    title?: ReactNode;
+    content?: ReactNode;
+    buttons?: ReactNode[];
+}
+/**
+ * A wrapper around Onsen's dialog, with support for standard layout + styling, titles and buttons
+ */
+export declare const Dialog: import("react").FC<DialogProps>, dialog: import("@xh/hoist/core").ElementFactory<DialogProps>;

package/build/types/mobile/cmp/dialog/index.d.ts

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

package/build/types/mobile/cmp/error/ErrorMessage.d.ts

@@ -0,0 +1,33 @@
+import { HoistProps, PlainObject } from '@xh/hoist/core';
+import { ButtonProps } from '@xh/hoist/mobile/cmp/button';
+import '@xh/hoist/mobile/register';
+import { ReactNode, MouseEvent } from 'react';
+import './ErrorMessage.scss';
+export interface ErrorMessageProps extends HoistProps {
+    /**
+     * If provided, will render a "Retry" button that calls this function.
+     * Use `actionButtonProps` for further control over this button.
+     */
+    actionFn?: (e: MouseEvent) => void;
+    /**
+     * If provided, component will render an inline action button - prompting to user to take some
+     * action that might resolve the error, such as retrying a failed data load.
+     */
+    actionButtonProps?: ButtonProps;
+    /**
+     * Error to display. If undefined, this component will look for an error property on its model.
+     * If no error is found, this component will not be displayed.
+     */
+    error?: Error | string | PlainObject;
+    /**
+     * Message to display for the error.
+     * Defaults to the error, or any 'message' property contained within it.
+     */
+    message?: ReactNode;
+    /** Optional title to display above the message. */
+    title?: ReactNode;
+}
+/**
+ * Component for displaying an error with standardized styling.
+ */
+export declare const ErrorMessage: import("react").FC<ErrorMessageProps>, errorMessage: import("@xh/hoist/core").ElementFactory<ErrorMessageProps>;

package/build/types/mobile/cmp/error/index.d.ts

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

package/build/types/mobile/cmp/form/FormField.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { BaseFormFieldProps } from '@xh/hoist/cmp/form';
+import '@xh/hoist/mobile/register';
+import './FormField.scss';
+export interface FormFieldProps extends BaseFormFieldProps {
+}
+/**
+ * Standardised wrapper around a HoistInput component for use in a form. FormField provides
+ * consistent layout, labelling, and optional display of validation messages for the field.
+ * FormField also supports an alternative read-only display of the bound data.
+ *
+ * This component is intended to be used within a `Form` component and bound to a 'FieldModel'
+ * within that Form's backing `FormModel`. FormField will set up the binding between its input and the
+ * FieldModel instance and can display validation messages, switch between read-only and disabled
+ * variants of its child, and source default props via the parent Form's `fieldDefaults` prop.
+ *
+ * This component is designed to work with an instance of `HoistInput` as its input, and makes use
+ * of many of HoistInput's props. For best results with a customized input, consider wrapping a
+ * HoistInput and passing all props along to it.   At the very least, all custom inputs
+ * must accept 'model' and 'bind' props in order to show and edit data.
+ *
+ * FormFields can be sized and otherwise customized via standard layout props. They will
+ * adjust their child inputs to fill their available space (if appropriate given the input type),
+ * so the recommended approach is to specify any sizing on the FormField (as opposed to the input).
+ */
+export declare const FormField: import("react").FC<FormFieldProps>, formField: import("@xh/hoist/core").ElementFactory<FormFieldProps>;

package/build/types/mobile/cmp/form/index.d.ts

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

package/build/types/mobile/cmp/grid/impl/ColChooser.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { HoistProps } from '@xh/hoist/core';
+import '@xh/hoist/mobile/register';
+import './ColChooser.scss';
+import { ColChooserModel } from './ColChooserModel';
+export interface ColChooserProps extends HoistProps<ColChooserModel> {
+}
+/**
+ * Hoist UI for user selection and discovery of available Grid columns, enabled via the
+ * GridModel.colChooserModel config option.
+ *
+ * This component displays available columns in a list, with currently visible columns
+ * identified by a checkmark icon to the right of the column name. Users can toggle column
+ * visibility within its associated grid by tapping this icon.
+ *
+ * User can drag and drop the columns in the list to reorder them in the grid.
+ *
+ * It derives its configuration primary from the Grid's Column definitions.
+ *
+ * It is not necessary to manually create instances of this component within an application.
+ */
+export declare const ColChooser: import("react").FC<ColChooserProps>, colChooser: import("@xh/hoist/core").ElementFactory<ColChooserProps>;