@xh/hoist 82.0.1 → 82.0.2

package/build/types/cmp/zoneGrid/ZoneGridModel.d.ts

@@ -0,0 +1,256 @@
+import { CellClickedEvent, CellContextMenuEvent, CellDoubleClickedEvent, RowClickedEvent, RowDoubleClickedEvent } from '@xh/hoist/kit/ag-grid';
+import { ColumnRenderer, ColumnSpec, GridContextMenuSpec, GridGroupSortFn, GridModel, GridSorter, GridSorterLike, GroupRowRenderer, RowClassFn, RowClassRuleFn, TreeStyle } from '@xh/hoist/cmp/grid';
+import { Awaitable, HoistModel, LoadSpec, PlainObject, Some, Thunkable, VSide } from '@xh/hoist/core';
+import { RecordAction, Store, StoreConfig, StoreRecordOrId, StoreSelectionConfig, StoreSelectionModel, StoreTransaction } from '@xh/hoist/data';
+import { ReactNode } from 'react';
+import { ZoneMapperConfig, ZoneMapperModel } from './impl/ZoneMapperModel';
+import { Zone, ZoneGridModelPersistOptions, ZoneLimit, ZoneMapping } from './Types';
+export interface ZoneGridConfig {
+    /**
+     * Available columns for this grid. Columns with an omit property evaluating to true will be
+     * excluded. Note that the actual display of the zone columns is managed via `mappings` below.
+     */
+    columns: Array<ColumnSpec>;
+    /** Mappings of columns to zones. */
+    mappings: Record<Zone, Some<string | ZoneMapping>>;
+    /** Optional configurations for zone constraints. */
+    limits?: Partial<Record<Zone, ZoneLimit>>;
+    /**
+     * Optional renderers to produce a row specific label for each column.
+     * If not specified, the label will default to the fixed  Header of the column.
+     */
+    labelRenderers?: Record<string, ColumnRenderer>;
+    /**
+     * Optional configs to apply to left column. Intended for use as an `escape hatch` - use with
+     * care. Settings made here may interfere with the implementation of this component.
+     */
+    leftColumnSpec?: Partial<ColumnSpec>;
+    /**
+     * Optional configs to apply to right column. Intended for use as an `escape hatch` - use with
+     * care. Settings made here may interfere with the implementation of this component.
+     */
+    rightColumnSpec?: Partial<ColumnSpec>;
+    /** String rendered between consecutive SubFields. */
+    delimiter?: string | false;
+    /** Config with which to create a ZoneMapperModel, or boolean `true` to enable default. */
+    zoneMapperModel?: ZoneMapperConfig | boolean;
+    /**
+     * A Store instance, or a config with which to create a Store.
+     * If not supplied, store fields will be inferred from columns config.
+     */
+    store?: Store | StoreConfig;
+    /** True if grid is a tree grid (default false). */
+    treeMode?: boolean;
+    /** Location for docked summary row(s). Requires `store.summaryRecords` to be populated. */
+    showSummary?: boolean | VSide;
+    /** Specification of selection behavior. Defaults to 'single' (desktop) and 'disabled' (mobile) */
+    selModel?: StoreSelectionModel | StoreSelectionConfig | 'single' | 'multiple' | 'disabled';
+    /**
+     * Function to be called when the user triggers ZoneGridModel.restoreDefaultsAsync().
+     * This function will be called after the built-in defaults have been restored, and can be
+     * used to restore application specific defaults.
+     */
+    restoreDefaultsFn?: () => Awaitable<void>;
+    /**
+     * Confirmation warning to be presented to user before restoring default state. Set to
+     * null to skip user confirmation.
+     */
+    restoreDefaultsWarning?: ReactNode;
+    /** Options governing persistence. */
+    persistWith?: ZoneGridModelPersistOptions;
+    /**
+     * Text/element to display if grid has no records. Defaults to null, in which case no empty
+     * text will be shown.
+     */
+    emptyText?: ReactNode;
+    /** True (default) to hide empty text until after the Store has been loaded at least once. */
+    hideEmptyTextBeforeLoad?: boolean;
+    /**
+     * Initial sort to apply to grid data.
+     * Note that unlike GridModel, multi-sort is not supported.
+     */
+    sortBy?: GridSorterLike;
+    /** Column ID(s) by which to do full-width grouping. */
+    groupBy?: Some<string>;
+    /** Group level to expand to on initial load. 0 = all collapsed, 1 = only top level expanded. */
+    expandLevel?: number;
+    /** True (default) to show a count of group member rows within each full-width group row. */
+    showGroupRowCounts?: boolean;
+    /** True to highlight the currently hovered row. */
+    showHover?: boolean;
+    /** True to render row borders. */
+    rowBorders?: boolean;
+    /** Specify treeMode-specific styling. */
+    treeStyle?: TreeStyle;
+    /** True to use alternating backgrounds for rows. */
+    stripeRows?: boolean;
+    /** True to render cell borders. */
+    cellBorders?: boolean;
+    /** True to highlight the focused cell with a border. */
+    showCellFocus?: boolean;
+    /** True to suppress display of the grid's header row. */
+    hideHeaders?: boolean;
+    /**
+     * Closure to generate CSS class names for a row.
+     * NOTE that, once added, classes will *not* be removed if the data changes.
+     * Use `rowClassRules` instead if StoreRecord data can change across refreshes.
+     */
+    rowClassFn?: RowClassFn;
+    /**
+     * Object keying CSS class names to functions determining if they should be added or
+     * removed from the row. See Ag-Grid docs on "row styles" for details.
+     */
+    rowClassRules?: Record<string, RowClassRuleFn>;
+    /** Height (in px) of a group row. Note that this will override `sizingMode` for group rows. */
+    groupRowHeight?: number;
+    /** Function used to render group rows. */
+    groupRowRenderer?: GroupRowRenderer;
+    /**
+     * Function to use to sort full-row groups.  Called with two group values to compare
+     * in the form of a standard JS comparator.  Default is an ascending string sort.
+     * Set to `null` to prevent sorting of groups.
+     */
+    groupSortFn?: GridGroupSortFn;
+    /**
+     * Callback when a key down event is detected on the grid. Note that the ag-Grid API provides
+     * limited ability to customize keyboard handling. This handler is designed to allow
+     * applications to work around this.
+     */
+    onKeyDown?: (e: KeyboardEvent) => void;
+    /**
+     * Callback when a row is clicked. (Note that the event received may be null - e.g. for
+     * clicks on full-width group rows.)
+     */
+    onRowClicked?: (e: RowClickedEvent) => void;
+    /**
+     * Callback when a row is double-clicked. (Note that the event received may be null - e.g.
+     * for clicks on full-width group rows.)
+     */
+    onRowDoubleClicked?: (e: RowDoubleClickedEvent) => void;
+    /**
+     * Callback when a cell is clicked.
+     */
+    onCellClicked?: (e: CellClickedEvent) => void;
+    /**
+     * Callback when a cell is double-clicked.
+     */
+    onCellDoubleClicked?: (e: CellDoubleClickedEvent) => void;
+    /**
+     * Callback when the context menu is opened. Note that the event received can also be
+     * triggered via a long press (aka tap and hold) on mobile devices.
+     */
+    onCellContextMenu?: (e: CellContextMenuEvent) => void;
+    /**
+     * Array of labels (or a function returning one) that describes the individual depth
+     * levels in a tree or grouped grid. If provided, will be used to construct expand/collapse
+     * options in the default context menu.
+     */
+    levelLabels?: Thunkable<string[]>;
+    /**
+     * Number of clicks required to expand / collapse a parent row in a tree grid. Defaults
+     * to 2 for desktop, 1 for mobile. Any other value prevents clicks on row body from
+     * expanding / collapsing (requires click on tree col affordance to expand/collapse).
+     */
+    clicksToExpand?: number;
+    /**
+     * Array of RecordActions, dividers, or token strings with which to create a context menu.
+     * May also be specified as a function returning same.
+     */
+    contextMenu?: GridContextMenuSpec;
+    /**
+     * Governs if the grid should reuse a limited set of DOM elements for columns visible in the
+     * scroll area (versus rendering all columns).  Consider this performance optimization for
+     * grids with a very large number of columns obscured by horizontal scrolling. Note that
+     * setting this value to true may limit the ability of the grid to autosize offscreen columns
+     * effectively. Default false.
+     */
+    useVirtualColumns?: boolean;
+    /**
+     * Set to true to if application will be reloading data when the sortBy property changes on
+     * this model (either programmatically, or via user-click.)  Useful for applications with large
+     * data sets that are performing external, or server-side sorting and filtering.  Setting this
+     * flag means that the grid should not immediately respond to user or programmatic changes to
+     * the sortBy property, but will instead wait for the next load of data, which is assumed to be
+     * pre-sorted. Default false.
+     */
+    externalSort?: boolean;
+    /**
+     * Set to true to highlight a row on click. Intended to provide feedback to users in grids
+     * without selection. Note this setting overrides the styling used by Column.highlightOnChange,
+     * and is not recommended for use alongside that feature. Default true for mobiles,
+     * otherwise false.
+     */
+    highlightRowOnClick?: boolean;
+    /**
+     * Flags for experimental features. These features are designed for early client-access and
+     * testing, but are not yet part of the Hoist API.
+     */
+    experimental?: PlainObject;
+    /** Extra app-specific data for the GridModel. */
+    appData?: PlainObject;
+    /** @internal */
+    xhImpl?: boolean;
+}
+/**
+ * ZoneGridModel is a wrapper around GridModel, which shows date in a grid with multi-line
+ * full-width rows, each broken into four zones for top/bottom and left/right.
+ *
+ * This is the primary app entry-point for specifying ZoneGrid component options and behavior.
+ */
+export declare class ZoneGridModel extends HoistModel {
+    gridModel: GridModel;
+    mapperModel: ZoneMapperModel;
+    mappings: Record<Zone, ZoneMapping[]>;
+    labelRenderers: Record<string, ColumnRenderer>;
+    leftColumnSpec: Partial<ColumnSpec>;
+    rightColumnSpec: Partial<ColumnSpec>;
+    availableColumns: ColumnSpec[];
+    limits: Partial<Record<Zone, ZoneLimit>>;
+    delimiter: string | false;
+    restoreDefaultsFn: () => Awaitable<void>;
+    restoreDefaultsWarning: ReactNode;
+    private _defaultState;
+    constructor(config: ZoneGridConfig);
+    /**
+     * Restore the mapping, sorting, and grouping configs as specified by the application at
+     * construction time. This is the state without any user changes applied.
+     * This method will clear the persistent grid state saved for this grid, if any.
+     *
+     * @returns true if defaults were restored
+     */
+    restoreDefaultsAsync(): Promise<boolean>;
+    showMapper(): void;
+    setMappings(mappings: Record<Zone, Some<string | ZoneMapping>>): void;
+    getDefaultContextMenu: () => (string | RecordAction)[];
+    get sortBy(): GridSorter;
+    setSortBy(cfg: GridSorterLike): void;
+    get store(): Store;
+    get empty(): boolean;
+    get selModel(): StoreSelectionModel;
+    get hasSelection(): boolean;
+    get selectedRecords(): import("@xh/hoist/data").StoreRecord[];
+    get selectedRecord(): import("@xh/hoist/data").StoreRecord;
+    get selectedId(): import("@xh/hoist/data").StoreRecordId;
+    get groupBy(): string[];
+    selectAsync(records: Some<StoreRecordOrId>, opts: {
+        ensureVisible?: boolean;
+        clearSelection?: boolean;
+    }): Promise<void>;
+    preSelectFirstAsync(): Promise<void>;
+    selectFirstAsync(opts?: {
+        ensureVisible?: boolean;
+    }): Promise<void>;
+    ensureSelectionVisibleAsync(): Promise<void>;
+    doLoadAsync(loadSpec: LoadSpec): Promise<any>;
+    loadData(rawData: any[], rawSummaryData?: Some<PlainObject>): void;
+    updateData(rawData: PlainObject[] | StoreTransaction): import("@xh/hoist/data").StoreChangeLog;
+    clear(): void;
+    setGroupBy(colIds: Some<string>): void;
+    private createGridModel;
+    private getColumns;
+    private buildZoneColumn;
+    private findColumnSpec;
+    private parseMappings;
+    private parseZoneMapping;
+    private parseMapperModel;
+}

package/build/types/cmp/zoneGrid/impl/InitPersist.d.ts

@@ -0,0 +1,7 @@
+import { ZoneGridModel } from '../ZoneGridModel';
+import { ZoneGridModelPersistOptions } from '../Types';
+/**
+ * Initialize persistence for a {@link ZoneGridModel} by applying its `persistWith` config.
+ * @internal
+ */
+export declare function initPersist(zoneGridModel: ZoneGridModel, { persistMappings, persistGrouping, persistSort, path, ...rootPersistWith }: ZoneGridModelPersistOptions): void;

package/build/types/cmp/zoneGrid/impl/ZoneGridRenderer.d.ts

@@ -0,0 +1,25 @@
+import { CellContext, ColumnRenderer } from '@xh/hoist/cmp/grid';
+import { ReactNode } from 'react';
+export interface ZoneGridColConfig {
+    /** Array of SubField specifications to render. */
+    subFields: ZoneGridSubField[];
+    /** Renderer for primary field. */
+    mainRenderer?: ColumnRenderer;
+    /** Separator rendered between consecutive SubFields. */
+    delimiter?: string | false;
+}
+export interface ZoneGridSubField {
+    colId: string;
+    /**
+     * Label to display next to data value. True to use the Column's header as label.
+     * Alternatively provide a custom string, or a renderer for dynamic per-value labels.
+     */
+    label?: boolean | string | ColumnRenderer;
+    /** Where to render the sub-field. Default 'bottom'. */
+    position?: 'top' | 'bottom';
+}
+/**
+ * Renderer to support ZoneGrid's highly specialized rendering.
+ * @internal
+ */
+export declare function zoneGridRenderer(value: any, context: CellContext, isLeft: boolean): ReactNode;

package/build/types/cmp/zoneGrid/impl/ZoneMapperModel.d.ts

@@ -0,0 +1,67 @@
+import { HoistModel } from '@xh/hoist/core';
+import { StoreRecord } from '@xh/hoist/data';
+import { GridSorter } from '@xh/hoist/cmp/grid';
+import { ReactNode } from 'react';
+import { ZoneGridModel } from '../ZoneGridModel';
+import { ZoneField, Zone, ZoneLimit, ZoneMapping } from '../Types';
+export interface ZoneMapperConfig {
+    /** The ZoneGridModel to be configured. */
+    zoneGridModel: ZoneGridModel;
+    /** True (default) to show Reset button to restore default configuration. */
+    showRestoreDefaults?: boolean;
+    /** True (default) to group columns by their chooserGroup */
+    groupColumns?: boolean;
+}
+/**
+ * State management for the ZoneMapper component.
+ *
+ * It is not necessary to manually create instances of this class within an application.
+ *
+ * @internal
+ */
+export declare class ZoneMapperModel extends HoistModel {
+    zoneGridModel: ZoneGridModel;
+    showRestoreDefaults: boolean;
+    groupColumns: boolean;
+    isOpen: boolean;
+    isPopoverOpen: boolean;
+    selectedZone: Zone;
+    mappings: Record<Zone, ZoneMapping[]>;
+    sortBy: GridSorter;
+    fields: ZoneField[];
+    sampleRecord: StoreRecord;
+    get isDirty(): boolean;
+    get leftFlex(): number;
+    get rightFlex(): number;
+    get limits(): Partial<Record<Zone, ZoneLimit>>;
+    get delimiter(): string | false;
+    get sortByColId(): string;
+    get sortByOptions(): {
+        value: string;
+        label: string;
+    }[];
+    get headersAreHidden(): boolean;
+    constructor(config: ZoneMapperConfig);
+    restoreDefaultsAsync(): Promise<void>;
+    open(): void;
+    openPopover(): void;
+    close(): void;
+    commit(): void;
+    getSamplesForZone(zone: Zone): ReactNode[];
+    getSortLabel(): "Abs" | "Asc" | "Desc";
+    getSortIcon(): any;
+    setSortByColId(colId: string): void;
+    setNextSortBy(): void;
+    toggleShown(field: string): void;
+    toggleShowLabel(field: string): void;
+    private syncMapperData;
+    private getFields;
+    private addOrAdjustZoneMapping;
+    private adjustZoneMapping;
+    private addZoneMapping;
+    private removeZoneMapping;
+    private getMappingForFieldAndZone;
+    private isZoneTopRow;
+    getSampleForMapping(mapping: ZoneMapping, ignoreLabel: boolean): ReactNode;
+    private getSampleRecord;
+}

package/build/types/cmp/zoneGrid/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Types';
+export * from './ZoneGrid';
+export * from './ZoneGridModel';

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

@@ -0,0 +1,139 @@
+import { ElementFactory, HoistAppModel, HoistAuthModel, HoistProps } from '@xh/hoist/core';
+import { Component, ComponentClass, FunctionComponent } from 'react';
+/**
+ * Spec for a client-side Hoist application. A config matching this class's shape is provided
+ * to {@link XHApi.renderApp} to kick-off app rendering and is available thereafter as `XH.appSpec`.
+ */
+export declare class AppSpec<T extends HoistAppModel = HoistAppModel> {
+    /**
+     * AuthModel class for the application. Note this is a reference to the class itself, not an
+     * instance, and must extend {@link HoistAuthModel}. If not provided, Hoist will fallback to
+     * the superclass implementation, but note that class would only be suitable for fully
+     * transparent SSO based solutions such as NTLM. Common patterns such as OAuth will require an
+     * extended implementation.
+     */
+    authModelClass?: new () => HoistAuthModel;
+    /**
+     * Method for determining if user may access the app. If a string, will be interpreted as the
+     * role required for basic UI access. Return false to show a generated lockout message, or use
+     * the object form to provide a custom message.
+     */
+    checkAccess: string | ((user: object) => boolean | {
+        hasAccess: boolean;
+        message: string;
+    });
+    /**
+     *  Short code for this particular JS client application.
+     *
+     *  Will default to the `appCode` specified within the project's Webpack config, but can be
+     *  set to a more specific value (e.g. 'myAppMobile') to identify the client app in common
+     *  code or configs that support distinct settings for different client apps.
+     */
+    clientAppCode?: string;
+    /**
+     * Display name for this particular JS client application.
+     *
+     * As with `clientAppCode` above, this will default to the global `appName` specified by
+     * the project's Webpack config, but can be set here to a more specific value (e.g.
+     * 'MyApp Mobile').
+     */
+    clientAppName?: string;
+    /**
+     * Root HoistComponent for the application.
+     * Despite the name, functional components are fully supported and expected.
+     */
+    componentClass: ComponentClass<HoistProps> | FunctionComponent<HoistProps>;
+    /**
+     * Container component to be used to host this application.
+     *
+     * This class determines the platform used by Hoist - almost all apps will import and specify
+     * either `@xh/hoist/desktop/AppContainer` or `@xh/hoist/mobile/AppContainer`.
+     */
+    containerClass: ComponentClass<HoistProps> | FunctionComponent<HoistProps>;
+    /**
+     * True to disable Hoist's built-in WebSocket support for this client app. Even if the app
+     * itself is not using WebSockets for business data, the Hoist Admin Console's "Clients" tab and
+     * related functionality benefit from having them enabled, so disable only if there is a good
+     * reason to do so.
+     */
+    disableWebSockets?: boolean;
+    /**
+     * True to enable Field-level XSS protection by default across all Stores/Fields in the app.
+     * Available as an extra precaution for use with apps that might display arbitrary input from
+     * untrusted or external users. This feature does exact a minor performance penalty during data
+     * parsing, which can be significant in aggregate for very large stores containing records with
+     * many `string` fields.
+     *
+     * Note: this flag and its default behavior was changed as of Hoist v77 to be `false`, i.e.
+     * Store-level XSS protection *disabled* by default, in keeping with Hoist's primary use-case:
+     * building secured internal apps with large datasets and tight performance tolerances.
+     *
+     * @see FieldSpec.enableXssProtection
+     */
+    enableXssProtection?: boolean;
+    /**
+     * True to show a login form on initialization when not authenticated. Default is `false` as
+     * most Hoist applications are expected to use OAuth or SSO for authn.
+     */
+    enableLoginForm?: boolean;
+    /**
+     * True to show logout options in the app, for apps with auth schemes that can support this
+     * operation (e.g. OAuth). Default is `false` as most Hoist applications are expected to use
+     * SSO or to run in internal environments where logout is not required / typical.
+     */
+    enableLogout?: boolean;
+    /**
+     * Optional custom Component to display when the app has been suspended. The component will
+     * receive a single `onReactivate` prop, a no-arg callback fired when the user has acknowledged
+     * the suspension and wishes to reload the app.
+     */
+    idlePanel?: ElementFactory | FunctionComponent | Component;
+    /** True if the app should use the Hoist mobile toolkit.*/
+    isMobileApp: boolean;
+    /**
+     * Optional custom Component to display when the user is denied access to app. Intended for
+     * apps that implement custom auth flows. See also `lockoutMessage` for a more lightweight
+     * customization option.
+     */
+    lockoutPanel?: ElementFactory | FunctionComponent | Component;
+    /** Optional message to show users when denied access to app. */
+    lockoutMessage?: string;
+    /** Optional message to show on login form, if `showLoginForm: true`. */
+    loginMessage?: string;
+    /**
+     * Root Model class for the application. Note this is a reference to the class itself, not an
+     * instance, and must extend {@link HoistAppModel}.
+     */
+    modelClass: new () => T;
+    /**
+     * True to show the built-in browser context menu when no app-specific menu would be shown
+     * (e.g. from a Grid). False (the default) prevents the browser menu from being shown anywhere
+     * upon right-click.
+     */
+    showBrowserContextMenu?: boolean;
+    /**
+     *  True (default) to write a track log statement after the app has loaded and fully
+     *  initialized, including a breakdown of elapsed time throughout the init process.
+     */
+    trackAppLoad?: boolean;
+    constructor({ authModelClass, checkAccess, clientAppCode, clientAppName, componentClass, containerClass, disableWebSockets, enableXssProtection, enableLoginForm, enableLogout, idlePanel, isMobileApp, lockoutMessage, lockoutPanel, loginMessage, modelClass, showBrowserContextMenu, trackAppLoad }: {
+        authModelClass?: typeof HoistAuthModel;
+        checkAccess: any;
+        clientAppCode?: string;
+        clientAppName?: string;
+        componentClass: any;
+        containerClass: any;
+        disableWebSockets?: boolean;
+        enableXssProtection?: boolean;
+        enableLoginForm?: boolean;
+        enableLogout?: boolean;
+        idlePanel?: any;
+        isMobileApp: any;
+        lockoutMessage?: any;
+        lockoutPanel?: any;
+        loginMessage?: any;
+        modelClass: any;
+        showBrowserContextMenu?: boolean;
+        trackAppLoad?: boolean;
+    });
+}

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

@@ -0,0 +1,132 @@
+import { HoistException } from '../exception';
+import { PlainObject } from './';
+export interface ExceptionHandlerOptions {
+    /** Text (ideally user-friendly) describing the error. */
+    message?: string;
+    /** Title for an alert dialog, if shown. */
+    title?: string;
+    /**
+     * Configure modal alert and logging to indicate that this is an unexpected error. Default
+     * true for most exceptions, false for those marked as `isRoutine`.
+     */
+    showAsError?: boolean;
+    /**
+     * Send the exception to the server to be stored for review in the Hoist Admin Console?
+     * Default true when `showAsError` is true, excepting 'isAutoRefresh' fetch exceptions.
+     */
+    logOnServer?: boolean;
+    /**
+     * Display an alert dialog to the user.
+     * Default true, excepting 'isAutoRefresh' and 'isFetchAborted' exceptions.
+     */
+    showAlert?: boolean;
+    /**
+     * If `showAlert`, which type of alert to display. Defaults to ExceptionHandler.ALERT_TYPE.
+     */
+    alertType?: 'dialog' | 'toast';
+    /**
+     * Force user to fully refresh the app in order to dismiss - default false, excepting
+     * session-related exceptions.
+     */
+    requireReload?: boolean;
+    /**
+     * A list of parameters that should be hidden from the exception log and alert.
+     */
+    hideParams?: string[];
+}
+export interface ExceptionHandlerLoggingOptions {
+    /** Exception to be logged. */
+    exception: HoistException;
+    /** True if the user was shown a modal alert. */
+    userAlerted: boolean;
+    /**
+     * Optional user-provided message detailing what they did to trigger the error, or any other
+     * details the user chooses to provide.
+     */
+    userMessage?: string;
+}
+/**
+ * Provides Centralized Exception Handling for Hoist Application.
+ * Manages the logging and display of exceptions.
+ */
+export declare class ExceptionHandler {
+    /**
+     * Property paths within error details JSON to replace with '******'
+     */
+    static REDACT_PATHS: string[];
+    /**
+     * Default type of alert to use to display exceptions with `showAlert`.
+     */
+    static ALERT_TYPE: 'dialog' | 'toast';
+    /**
+     * Default props provided to toast, when alert type is 'toast'
+     */
+    static TOAST_PROPS: object;
+    /**
+     * Called by Hoist internally to handle exceptions, with built-in support for parsing certain
+     * Hoist-specific exception options, displaying an appropriate error dialog to users, and
+     * logging back to the server for stateful error tracking in the Admin Console.
+     *
+     * Typical application entry points to this method are the {@link XH.handleException} alias and
+     * {@link Promise.prototype.catchDefault}.
+     *
+     * This handler provides the most value with HoistExceptions created by {@link Exception.create}.
+     * Hoist automatically creates such exceptions in most instances, most notably in FetchService,
+     * which generates de-serialized versions of server exceptions. See {@link XH.exception} for a
+     * convenient way to create these enhanced exceptions in application code.
+     *
+     * This handler will respect an `isRoutine` flag set on HoistExceptions that can be thrown in
+     * the course of "normal" app operation and do not represent unexpected errors. When true, this
+     * handler will apply defaults that avoid overly alarming the user and skip server-side logging.
+     *
+     * @param exception - thrown object, will be coerced into a HoistException by Exception.create().
+     * @param options - provides further control over how the exception is shown and/or logged.
+     */
+    handleException(exception: unknown, options?: ExceptionHandlerOptions): void;
+    /**
+     * Show an exception in an error dialog, without logging the error to the server or console.
+     * Intended to be used for the deferred / user-initiated showing of exceptions that have
+     * already been appropriately logged. Applications should typically prefer `handleException`.
+     *
+     * @param exception - thrown object, will be coerced into a HoistException by Exception.create().
+     * @param options - provides further control over how the exception is shown and/or logged.
+     */
+    showException(exception: unknown, options?: ExceptionHandlerOptions): void;
+    /**
+     * Show an exception in full detail, with ability to report and copy to clipboard.
+     * Intended to be used for the deferred / user-initiated showing of exceptions that have
+     * already been appropriately logged. Apps should typically prefer {@link handleException}.
+     *
+     * @param exception - thrown object, will be coerced into a {@link HoistException}.
+     * @param options - provides further control over how the exception is shown.
+     */
+    showExceptionDetails(exception: unknown, options?: ExceptionHandlerOptions): void;
+    /**
+     * Create a server-side exception entry. Client metadata will be set automatically.
+     *
+     * This method will swallow any exceptions thrown in the course of its own execution, failing
+     * silently to avoid masking or compounding the actual exception to be handled.
+     *
+     * Note the App version is POSTed to ensure we capture the version of the client the user is
+     * actually running when the exception was generated.
+     *
+     * @returns true if message was successfully sent to server.
+     */
+    logOnServerAsync(options: ExceptionHandlerLoggingOptions): Promise<boolean>;
+    /**
+     * Sanitize an exception for submission to server. This method will avoid circular references
+     * trim the depth of the object, and redact sensitive info (e.g. passwords).
+     */
+    sanitizeException(exception: HoistException): PlainObject;
+    /**
+     * Serialize an error object safely for user display.  This method will avoid circular
+     * references, trim the depth of the object, and redact sensitive info (e.g. passwords).
+     */
+    stringifyErrorSafely(exception: HoistException): string;
+    private parseArgs;
+    private hideParams;
+    private logException;
+    private parseOptions;
+    private sessionMismatch;
+    private cloneAndTrim;
+}