@xh/hoist 57.0.0 → 57.0.1

package/build/types/mobile/appcontainer/LockoutPanel.d.ts

@@ -0,0 +1,7 @@
+import './LockoutPanel.scss';
+/**
+ * Panel for display to prevent user access to all content.
+ *
+ * @internal
+ */
+export declare const lockoutPanel: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

package/build/types/mobile/appcontainer/LoginPanel.d.ts

@@ -0,0 +1,9 @@
+import { LoginPanelModel } from '@xh/hoist/appcontainer/login/LoginPanelModel';
+import './LoginPanel.scss';
+/**
+ * A minimal username / password prompt for applications using form-based authentication.
+ * Automatically created and displayed if required by AppContainer.
+ *
+ * @internal
+ */
+export declare const loginPanel: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<LoginPanelModel>>;

package/build/types/mobile/appcontainer/Message.d.ts

@@ -0,0 +1,7 @@
+import { MessageModel } from '@xh/hoist/appcontainer/MessageModel';
+import './Message.scss';
+/**
+ * Renders a modal dialog.
+ * @internal
+ */
+export declare const message: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<MessageModel>>;

package/build/types/mobile/appcontainer/MessageSource.d.ts

@@ -0,0 +1,6 @@
+import { MessageSourceModel } from '@xh/hoist/appcontainer/MessageSourceModel';
+/**
+ *  Support for hosting multiple global Messages in the DOM.
+ *  @internal
+ */
+export declare const messageSource: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<MessageSourceModel>>;

package/build/types/mobile/appcontainer/OptionsDialog.d.ts

@@ -0,0 +1,6 @@
+import { OptionsDialogModel } from '@xh/hoist/appcontainer/OptionsDialogModel';
+import './OptionsDialog.scss';
+/**
+ * @internal
+ */
+export declare const optionsDialog: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<OptionsDialogModel>>;

package/build/types/mobile/appcontainer/SuspendPanel.d.ts

@@ -0,0 +1,6 @@
+import './SuspendPanel.scss';
+/**
+ * Generic Panel to display when the app is suspended.
+ * @internal
+ */
+export declare const suspendPanel: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

package/build/types/mobile/appcontainer/Toast.d.ts

@@ -0,0 +1,6 @@
+import { ToastModel } from '@xh/hoist/appcontainer/ToastModel';
+import './Toast.scss';
+/**
+ * @internal
+ */
+export declare const toast: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<ToastModel>>;

package/build/types/mobile/appcontainer/ToastSource.d.ts

@@ -0,0 +1,7 @@
+import { ToastSourceModel } from '@xh/hoist/appcontainer/ToastSourceModel';
+/**
+ * Support for rendering Toast alerts.
+ * This component uses a queue based approach, ensuring only one toast is showing at a time.
+ * @internal
+ */
+export declare const toastSource: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<ToastSourceModel>>;

package/build/types/mobile/appcontainer/VersionBar.d.ts

@@ -0,0 +1,5 @@
+import './VersionBar.scss';
+/**
+ * @internal
+ */
+export declare const versionBar: import("@xh/hoist/core").ElementFactory<import("@xh/hoist/core").DefaultHoistProps<import("@xh/hoist/core").HoistModel>>;

package/build/types/mobile/appcontainer/index.d.ts

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

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

@@ -0,0 +1,333 @@
+/// <reference types="react" />
+import { SwitchInputProps } from '@xh/hoist/mobile/cmp/input';
+import { FormFieldProps } from '@xh/hoist/mobile/cmp/form';
+import '@xh/hoist/mobile/register';
+interface AutoRefreshAppOptionSpec {
+    /** Props for nested FormField. */
+    formFieldProps?: FormFieldProps;
+    /** Props for nested SwitchInput. */
+    inputProps?: SwitchInputProps;
+}
+/**
+ * Convenience configuration for the `autoRefresh` AppOption.
+ */
+export declare const autoRefreshAppOption: ({ formFieldProps, inputProps }?: AutoRefreshAppOptionSpec) => {
+    omit: boolean;
+    name: string;
+    prefName: 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<SwitchInputProps, any>;
+    };
+};
+export {};