@xh/hoist 57.0.0 → 57.0.2

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { PersistenceProvider, PersistOptions } from './';
+/**
+ * PersistenceProvider that stores state within a DashViewModel.
+ */
+export declare class DashViewProvider extends PersistenceProvider {
+    dashViewModel: any;
+    constructor({ dashViewModel, ...rest }: PersistOptions);
+    readRaw(): any;
+    writeRaw(data: any): void;
+    clearRaw(): any;
+}

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

@@ -0,0 +1,11 @@
+import { PersistenceProvider, PersistOptions } from './';
+/**
+ * PersistenceProvider that stores state within the Browser's LocalStorage.
+ */
+export declare class LocalStorageProvider extends PersistenceProvider {
+    key: string;
+    constructor({ localStorageKey: key, ...rest }: PersistOptions);
+    readRaw(): any;
+    writeRaw(data: any): void;
+    clearRaw(): void;
+}

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

@@ -0,0 +1,31 @@
+import { DebounceSpec } from '../';
+/**
+ * Options governing persistence.
+ */
+export interface PersistOptions {
+    /** Dot delimited path to store state. */
+    path?: string;
+    /** Debounce interval in ms, or a lodash debounce config. */
+    debounce?: DebounceSpec;
+    /**
+     * Type of PersistenceProvider to create. If not provided, defaulted based
+     * on the presence of `prefKey`, `localStorageKey`, `dashViewModel`, `getData` and `setData`.
+     */
+    type?: string;
+    /** Predefined Hoist application Preference key used to store state. */
+    prefKey?: string;
+    /** Browser local storage key used to store state. */
+    localStorageKey?: string;
+    /** DashViewModel used to read / write view state. */
+    dashViewModel?: object;
+    /**
+     *  Function returning blob of data to be used for reading state.
+     *  Ignored if `prefKey`, `localStorageKey` or `dashViewModel` are provided.
+     */
+    getData?: () => any;
+    /**
+     * Function to be used to write blob of data representing state.
+     * Ignored if `prefKey`, `localStorageKey` or `dashViewModel` are provided.
+     */
+    setData?: (data: object) => void;
+}

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

@@ -0,0 +1,49 @@
+import { DebounceSpec } from '../';
+import { PersistOptions } from './';
+/**
+ * Abstract superclass for adaptor objects used by models and components to (re)store state to and
+ * from a persistent location, typically a Hoist preference or key within browser local storage.
+ *
+ * Note that multiple instances of this object may be writing into the same location.
+ * Implementations should take care to incorporate any writes immediately into the readable state.
+ *
+ * Hoist-provided implementations include:
+ *   - {@link PrefProvider} - stores state in a predefined Hoist application Preference.
+ *   - {@link LocalStorageProvider} - stores state in browser local storage under a configured key.
+ *   - {@link DashViewProvider} - stores state with other Dashboard-specific state via a `DashViewModel`.
+ *   - {@link CustomProvider} - API for app and components to provide their own storage mechanism.
+ */
+export declare class PersistenceProvider {
+    get isPersistenceProvider(): boolean;
+    path: string;
+    debounce: DebounceSpec;
+    /**
+     * Construct an instance of this class.
+     */
+    static create({ type, ...rest }: PersistOptions): PersistenceProvider;
+    /**
+     * Called by implementations only. See create.
+     */
+    protected constructor({ path, debounce }: PersistOptions);
+    /**
+     * Read data at a path
+     */
+    read(): any;
+    /**
+     * Save data at a path
+     * @param data  - data to be written to the path, must be serializable to JSON.
+     */
+    write(data: any): void;
+    /**
+     * Clear any state saved by this object at a path
+     */
+    clear(path?: string): void;
+    /**
+     * Clear *all* state held by this object.
+     */
+    clearAll(): void;
+    protected writeInternal(data: object): void;
+    protected writeRaw(obj: object): void;
+    protected readRaw(): object;
+    protected clearRaw(): void;
+}

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

@@ -0,0 +1,11 @@
+import { PersistenceProvider, PersistOptions } from './';
+/**
+ * PersistenceProvider that stores state within the Hoist Preferences system.
+ */
+export declare class PrefProvider extends PersistenceProvider {
+    key: string;
+    constructor({ prefKey: key, ...rest }: PersistOptions);
+    readRaw(): any;
+    writeRaw(data: any): void;
+    clearRaw(): void;
+}

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

@@ -0,0 +1,6 @@
+export * from './PersistOptions';
+export * from './PersistenceProvider';
+export * from './LocalStorageProvider';
+export * from './DashViewProvider';
+export * from './PrefProvider';
+export * from './CustomProvider';

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

@@ -0,0 +1,232 @@
+import { RuleLike } from '@xh/hoist/data';
+import { ReactElement, ReactNode } from 'react';
+import { LoadSpec } from '../load';
+import { Intent, Thunkable } from './Types';
+/**
+ * User of the application, as loaded from the server.
+ *
+ * Note that instances of this class may contain other custom properties serialize by an
+ * application.  Applications may wish to extend this interface
+ */
+export interface HoistUser {
+    username: string;
+    email: string;
+    displayName: string;
+    roles: string[];
+    isHoistAdmin: boolean;
+    isHoistAdminReader: boolean;
+    hasRole(s: string): boolean;
+    hasGate(s: string): boolean;
+}
+/**
+ * Enhanced Response returned by FetchService.
+ */
+export interface FetchResponse extends Response {
+    /**
+     * Property containing the already-awaited output of `response.text()`.
+     */
+    responseText: string;
+}
+/**
+ * Options for showing a "toast" notification that appears and then automatically dismisses.
+ */
+export interface ToastSpec {
+    message: ReactNode;
+    icon?: ReactElement;
+    intent?: Intent;
+    /**
+     * Time in ms to show before auto-dismissing the toast, or null to keep toast
+     * visible until manually dismissed.  Default 3000.
+     */
+    timeout?: number;
+    /**
+     * If provided, will render a button within the toast to enable the user to take some
+     * specific action right from the toast.
+     */
+    actionButtonProps?: any;
+    /**
+     * Relative position at which to display toast, e.g. "bottom-right" (default) or "top".
+     * (Desktop only.)
+     */
+    position?: string;
+    /**
+     * DOM element relative to which the toast should be positioned. If null, Toast will show
+     * along edge of overall document. (Desktop only.)
+     */
+    containerRef?: HTMLElement;
+}
+/**
+ * Options for showing a modal alert, confirm, or prompt.
+ */
+export interface MessageSpec {
+    message?: ReactNode;
+    title?: string;
+    icon?: ReactElement;
+    className?: string;
+    /**
+     * Unique key identifying the message. If subsequent messages.
+     * If subsequent messages are triggered with this key, they will replace this message.
+     * Useful for usages that may be producing messages recursively, or via timers and wish to
+     * avoid generating a large stack of duplicates.
+     */
+    messageKey?: string;
+    /** Config for input to be displayed (as a prompt). */
+    input?: {
+        /** An element specifying a HoistInput, defaults to a platform appropriate TextInput. */
+        item?: ReactElement;
+        /** Validation constraints to apply. */
+        rules?: RuleLike[];
+        /** Initial value for the input. */
+        initialValue?: any;
+    };
+    /**
+     * Props for primary confirm button.
+     * Must provide either text or icon for button to be displayed, or use a preconfigured
+     * helper such as `XH.alert()` or `XH.confirm()` for default buttons.
+     */
+    confirmProps?: any;
+    /**
+     * Props for secondary cancel button.
+     * Must provide either text or icon for button to be displayed, or use a preconfigured
+     * helper such as `XH.alert()` or `XH.confirm()` for default buttons.
+     */
+    cancelProps?: any;
+    /**
+     * Specify 'left' to place the Cancel button (if shown) on the
+     * left edge of the dialog toolbar, with a filler between it and Confirm.
+     */
+    cancelAlign?: any;
+    /** Callback to execute when confirm is clicked.*/
+    onConfirm?(): any;
+    /** Callback to execute when cancel is clicked.*/
+    onCancel?(): any;
+    /** Flag to specify whether a popup can be clicked out of or escaped.*/
+    dismissable?: boolean;
+    /** Flag to specify whether onCancel is executed when clicking out of or escaping a popup. */
+    cancelOnDismiss?: boolean;
+}
+/**
+ * Configuration object for an app-wide banner.
+ */
+export interface BannerSpec {
+    message?: ReactNode;
+    icon?: ReactElement;
+    intent?: Intent;
+    className?: string;
+    /**
+     * Determines order in which banner will be displayed.
+     * If not provided, banner will be placed below any existing banners.
+     * @see BannerModel.BANNER_SORTS
+     */
+    sortOrder?: number;
+    /**
+     * Showing a banner with a given category will hide any
+     * preexisting banner with the same category.
+     */
+    category?: string;
+    /**
+     *  Callback function triggered when the user clicks the close button.
+     *  (Note, banners closed via `XH.hideBanner()` or when the max
+     *  number of banners shown is exceeded will NOT trigger this callback.)
+     */
+    onClose?(model: any): any;
+    /**
+     * Callback function triggered when the user clicks on the banner.
+     */
+    onClick?(model: any): any;
+    /**
+     *  If provided, will render a button within the banner to enable the user to
+     *  take some specific action right from the banner.
+     */
+    actionButtonProps?: object;
+    /** Enable the Banner to be closed? Defaults to true. */
+    enableClose?: boolean;
+}
+/**
+ * Option for Application option in the application.
+ */
+export interface AppOptionSpec {
+    name: string;
+    prefName?: string;
+    /** Config for FormField for this option. */
+    formField: any;
+    /** Config for FieldModel for the option.*/
+    fieldModel?: any;
+    /** Function, possibly async, which returns the value. */
+    valueGetter?: () => any;
+    /** Function, possibly async, which sets the value. */
+    valueSetter?: (s: any) => any;
+    /** True to reload the app after changing this option.  Default false. */
+    reloadRequired?: boolean;
+    /** Optional flag to omit displaying option. */
+    omit?: Thunkable<boolean>;
+}
+/**
+ * Options for tracking activity on the server via TrackService.
+ */
+export interface TrackOptions {
+    /** Short description of the activity being tracked. */
+    message: string;
+    /** App-supplied category.*/
+    category?: string;
+    /** App-supplied data to save along with track log.*/
+    data?: object | object[];
+    /**
+     * Flag to indicate relative importance of activity.
+     * Default 'INFO'. Note, errors should be tracked via {@link XH.handleException}, which
+     * will post to the server for dedicated logging if requested.
+     */
+    severity?: string;
+    /**
+     * Set to true to log this message only once during the current session. The category and
+     * message text will be used as a compound key to identify repeated messages.
+     */
+    oncePerSession?: boolean;
+    /** Optional LoadSpec associated with this track.*/
+    loadSpec?: LoadSpec;
+    /** Elapsed time (ms) for action. */
+    elapsed?: number;
+    /** Optional flag to omit sending message. */
+    omit?: Thunkable<boolean>;
+}
+/**
+ *  Basic interface for a MenuItem to appear in a menu.
+ *
+ *  MenuItems can be displayed within a context menu, or shown when clicking on a button.
+ */
+export interface MenuItem {
+    /** Label to be displayed. */
+    text: ReactNode;
+    /** Icon to be displayed. */
+    icon?: ReactElement;
+    /** Intent to be used for rendering the action. */
+    intent?: Intent;
+    /** Executed when the user clicks the menu item. */
+    actionFn?: () => void;
+    /** Executed before the item is shown.  Use to adjust properties dynamically. */
+    prepareFn?: (me: MenuItem) => void;
+    /** Child menu items. */
+    items?: MenuItemLike[];
+    /** True to disable this item. */
+    disabled?: boolean;
+    /** True to hide this item. May be set dynamically via prepareFn.*/
+    hidden?: boolean;
+    /** True to skip this item. May be set dynamically via prepareFn. Alias for hidden.  */
+    omit?: Thunkable<boolean>;
+}
+/**
+ * An item that can exist in a Menu.
+ *
+ * Allows for a ReactNode as divider.  If strings are specified, the implementations may choose
+ * an appropriate default display, with '-' providing a standard textless divider that will also
+ * be de-duped if appearing at the beginning, or end, or adjacent to another divider at render time.
+ */
+export type MenuItemLike = MenuItem | ReactNode;
+/**
+ * An option to be passed to Select controls
+ */
+export interface SelectOption {
+    value?: any;
+    label?: string;
+    options?: (SelectOption | any)[];
+}

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

@@ -0,0 +1,41 @@
+import { ElementFactory } from '@xh/hoist/core';
+import { LocalDate } from '@xh/hoist/utils/datetime';
+import { MomentInput } from 'moment';
+import { Component, FunctionComponent, ReactElement } from 'react';
+import { DebounceSettings } from 'lodash';
+/** Values available for intents. */
+export type Intent = 'primary' | 'success' | 'warning' | 'danger';
+/** Values available for App Theme. */
+export type Theme = 'system' | 'dark' | 'light';
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+export type VSide = 'top' | 'bottom';
+export type HSide = 'left' | 'right';
+export type Corner = 'tl' | 'tr' | 'bl' | 'br';
+export type HAlign = 'left' | 'right' | 'center';
+export type VAlign = 'top' | 'bottom' | 'center';
+/** Convenience type for common pattern of accepting a single T, or an array of Ts. */
+export type Some<T> = T | T[];
+export type Thunkable<T> = T | (() => T);
+export type Awaitable<T> = Promise<T> | T;
+/** Convenience type for a "plain", string-keyed object holding any kind of values. */
+export type PlainObject = Record<string, any>;
+/**
+ * Specification for debouncing in Hoist.
+ *
+ * When specified as object, should contain an 'interval' and other optional keys for
+ * lodash.  If specified as number the default lodash debounce will be used.
+ */
+export type DebounceSpec = number | (DebounceSettings & {
+    interval: number;
+});
+/**
+ * Argument passed to components that create views on demand.
+ *
+ * Used by the TabContainer, DashContainer, DockView, and Navigator APIs to process the 'content'
+ * configs provided to them for their tabs and views.
+ *
+ * Can be a ReactElement, HoistComponent or function. If a function, it may be an ElemFactory or any
+ * function that returns a ReactElement. In either case, the function will be called with no arguments.
+ */
+export type Content = ReactElement | FunctionComponent | Component | ElementFactory | (() => ReactElement);
+export type DateLike = Date | LocalDate | MomentInput;

package/build/types/data/Field.d.ts

@@ -0,0 +1,72 @@
+import { Rule, RuleLike } from './validation/Rule';
+/**
+ * Constructor arguments for a Hoist data package Field.
+ */
+export interface FieldSpec {
+    /** Unique key representing this field. */
+    name: string;
+    /** default `'auto` indicates no conversion.*/
+    type?: FieldType;
+    /**
+     *  User-facing / longer name for display, defaults to `name`
+     *  transformed via `genDisplayName()` (e.g. 'myField' translates to 'My Field').
+     */
+    displayName?: string;
+    /** Value to be used for records with a null, or non-existent value. */
+    defaultValue?: any;
+    /** Rules to apply to this field. */
+    rules?: RuleLike[];
+    /**
+     * True to disable built-in XSS (cross-site scripting) protection, applied by default to all
+     * incoming String values using {@link https://github.com/cure53/DOMPurify | DOMPurify}.
+     *
+     * DOMPurify provides fast escaping of dangerous HTML, scripting, and other content that can be
+     * used to execute XSS attacks, while allowing common and expected HTML and style tags.
+     *
+     * Please contact XH if you find yourself needing to disable this protection!
+     */
+    disableXssProtection?: boolean;
+}
+/** Metadata for an individual data field within a {@link StoreRecord}. */
+export declare class Field {
+    get isField(): boolean;
+    readonly name: string;
+    readonly type: FieldType;
+    readonly displayName: string;
+    readonly defaultValue: any;
+    readonly rules: Rule[];
+    readonly disableXssProtection: boolean;
+    constructor({ name, type, displayName, defaultValue, rules, disableXssProtection }: FieldSpec);
+    parseVal(val: any): any;
+    isEqual(val1: any, val2: any): boolean;
+    private processRuleSpecs;
+}
+/**
+ * Parse a value according to a field type.
+ * @param val - raw value to parse.
+ * @param type - data type of the field to use for possible conversion.
+ * @param defaultValue - typed value to return if `val` undefined or null.
+ * @param disableXssProtection - true to disable XSS (cross-site scripting) protection.
+ *      @see {@link FieldConfig} docs for additional details.
+ * @returns resulting value, potentially parsed or cast as per type.
+ */
+export declare function parseFieldValue(val: any, type: FieldType, defaultValue?: any, disableXssProtection?: boolean): any;
+/** Data types for Fields used within Hoist Store Records and Cubes. */
+export declare const FieldType: Readonly<{
+    TAGS: "tags";
+    AUTO: "auto";
+    BOOL: "bool";
+    DATE: "date";
+    INT: "int";
+    JSON: "json";
+    LOCAL_DATE: "localDate";
+    NUMBER: "number";
+    PWD: "pwd";
+    STRING: "string";
+}>;
+export type FieldType = (typeof FieldType)[keyof typeof FieldType];
+/**
+ * @param fieldName - short name / code for a field.
+ * @returns fieldName transformed into user-facing / longer name for display.
+ */
+export declare function genDisplayName(fieldName: string): string;

package/build/types/data/RecordAction.d.ts

@@ -0,0 +1,114 @@
+import { ReactElement } from 'react';
+import { Intent, PlainObject } from '../core';
+import { StoreRecord } from './StoreRecord';
+import { GridModel, Column } from '../cmp/grid';
+export interface RecordActionSpec {
+    /** Label to be displayed. */
+    text?: string;
+    /** Additional label to be displayed, usually in a minimal fashion.*/
+    secondaryText?: string;
+    /** Icon to be displayed.*/
+    icon?: ReactElement;
+    /** Intent to be used for rendering the action.*/
+    intent?: Intent;
+    /** Css class name to be added when rendering the action. */
+    className?: string;
+    /** Tooltip to display when hovering over the action. */
+    tooltip?: string;
+    /** Function called on action execution. */
+    actionFn?: (data: ActionFnData) => void;
+    /** Function called prior to showing this item. */
+    displayFn?: (data: DisplayFnData) => PlainObject;
+    /** Sub-actions for this action. */
+    items?: RecordActionLike[];
+    /** True to disable this item. */
+    disabled?: boolean;
+    /** True to hide this item. */
+    hidden?: boolean;
+    /**
+     * Count of records that must be 'active' (selected and / or clicked upon) for the action to be
+     * enabled.
+     *  - int: specifies exactly n number of records. Defaults to 1 for single record actions.
+     *      Can specify 0 to only enable action if *no* records are active.
+     *  - true: specifies a non-zero number of records.
+     *  - false: specifies any number of records (0 - infinity, inclusive). Always active.
+     */
+    recordsRequired?: boolean | number;
+}
+export type RecordActionLike = RecordAction | RecordActionSpec | '-';
+/**
+ * Data passed to the Action Function of a RecordAction
+ */
+export interface ActionFnData {
+    /** The triggering action itself. */
+    action?: RecordAction;
+    /** Row data object (entire row, if any).*/
+    record?: any;
+    /** All currently selected records (if any).*/
+    selectedRecords?: StoreRecord[];
+    /** Grid model where action occurred (if any). */
+    gridModel?: GridModel;
+    /** Column where action occurred (if any). */
+    column?: Column;
+    /** Additional data provided by the context where this action presides */
+    [x: string]: any;
+}
+/**
+ * A RecordAction encapsulates a shared set of configuration for items within components such as
+ * a Grid Context Menu nd RecordActionBar (aka grid context menus and action columns).
+ *
+ * Components passed these actions will render them with an appropriate UI (e.g. menu item, button)
+ * and call their `actionFn` when clicked, passing it a data object (if available) sourced from the
+ * selected row(s) or node(s) on the underlying grid or data view.
+ *
+ * The `displayFn` callback allows apps to customize any display properties of the action prior to
+ * each render by returning an object with keys/values to override (e.g. `{hidden: true}`).
+ *
+ * NOTE that both `actionFn` and `displayFn` can be called with a null record - e.g. when showing a
+ * context menu on a full-width grid group row, where there is no backing record for the row.
+ * Applications should ensure these callbacks handle their `record` param in a null-safe manner.
+ *
+ * @see RecordActionBar
+ * @see GridContextMenuSpec
+ */
+export declare class RecordAction {
+    text: string;
+    secondaryText: string;
+    icon: ReactElement;
+    intent: Intent;
+    className: string;
+    tooltip: string;
+    actionFn: (data: ActionFnData) => void;
+    displayFn: (data: DisplayFnData) => PlainObject;
+    items: Array<RecordAction | string>;
+    disabled: boolean;
+    hidden: boolean;
+    recordsRequired: boolean | number;
+    constructor({ text, secondaryText, icon, intent, className, tooltip, actionFn, items, disabled, hidden, displayFn, recordsRequired }: RecordActionSpec);
+    /**
+     * Called by UI elements to get the display configuration for rendering the action.
+     * @internal
+     */
+    getDisplaySpec({ record, selectedRecords, gridModel, column, ...rest }: ActionFnData): {
+        icon: ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        text: string;
+        secondaryText: string;
+        intent: Intent;
+        className: string;
+        tooltip: string;
+        items: (string | RecordAction)[];
+        hidden: boolean;
+        disabled: boolean;
+    };
+    /**
+     * Called by UI elements to trigger the action.
+     * @internal
+     */
+    call({ record, selectedRecords, gridModel, column, ...rest }: ActionFnData): void;
+    private meetsRecordRequirement;
+}
+interface DisplayFnData extends ActionFnData {
+    /** Default display config for the action */
+    defaultConfig?: PlainObject;
+}
+export {};