@xh/hoist 82.0.1 → 82.0.3

package/build/types/cmp/grid/GridModel.d.ts

@@ -0,0 +1,624 @@
+import { AgGridModel } from '@xh/hoist/cmp/ag-grid';
+import { Column, ColumnGroup, ColumnOrGroup, ColumnOrGroupSpec, ColumnSpec, GridAutosizeMode, GridFilterModelConfig, GridGroupSortFn, TreeStyle } from '@xh/hoist/cmp/grid';
+import { GridFilterModel } from '@xh/hoist/cmp/grid/filter/GridFilterModel';
+import { Awaitable, HoistModel, HSide, LoadSpec, PlainObject, SizingMode, Some, TaskObserver, Thunkable, VSide } from '@xh/hoist/core';
+import { Store, StoreConfig, StoreRecord, StoreRecordId, StoreRecordOrId, StoreSelectionConfig, StoreSelectionModel, StoreTransaction } from '@xh/hoist/data';
+import { AgColumnState, CellClickedEvent, CellContextMenuEvent, CellDoubleClickedEvent, CellEditingStartedEvent, CellEditingStoppedEvent, RowClickedEvent, RowDoubleClickedEvent } from '@xh/hoist/kit/ag-grid';
+import { ExportOptions } from '@xh/hoist/svc/GridExportService';
+import { ReactNode, RefObject } from 'react';
+import { GridAutosizeOptions } from './GridAutosizeOptions';
+import { GridContextMenuSpec } from './GridContextMenu';
+import { GridSorter, GridSorterLike } from './GridSorter';
+import { ColChooserConfig, ColumnState, GridModelPersistOptions, GroupRowRenderer, RowClassFn, RowClassRuleFn } from './Types';
+export interface GridConfig {
+    /** Columns for this grid. */
+    columns?: ColumnOrGroupSpec[];
+    /**  Column configs to be set on all columns.  Merges deeply. */
+    colDefaults?: Partial<ColumnSpec>;
+    /**
+     * 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';
+    /** Config with which to create a GridFilterModel, or `true` to enable default. Desktop only.*/
+    filterModel?: GridFilterModelConfig | boolean;
+    /** Config with which to create a ColChooserModel, or boolean `true` to enable default.*/
+    colChooserModel?: Omit<ColChooserConfig, 'gridModel'> | boolean;
+    /**
+     * Function to be called when the user triggers GridModel.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 grid state. Set to
+     * null to skip user confirmation.
+     */
+    restoreDefaultsWarning?: ReactNode;
+    /** Options governing persistence. */
+    persistWith?: GridModelPersistOptions;
+    /**
+     * 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. */
+    sortBy?: Some<GridSorterLike>;
+    /** Column ID(s) by which to do full-width grouping. */
+    groupBy?: Some<string>;
+    /**
+     * Depth level to expand to on initial load. 0 = all collapsed, 1 = top level expanded, etc.
+     * Defaults to 0 for tree grids (i.e. treeMode = true), 1 for standard grouped grids.
+     */
+    expandLevel?: number;
+    /** True (default) to show a count of group member rows within each full-width group row. */
+    showGroupRowCounts?: boolean;
+    /** Size of text in grid.  If undefined, will default and bind to `XH.sizingMode`. */
+    sizingMode?: SizingMode;
+    /** 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;
+    /** 'hover' to only show column header menu icons on hover. */
+    headerMenuDisplay?: 'always' | 'hover';
+    /** True to disallow moving columns outside of their groups. */
+    lockColumnGroups?: boolean;
+    /** True to allow the user to manually pin / unpin columns via UI affordances. */
+    enableColumnPinning?: boolean;
+    /** True to enable exporting this grid and install default context menu items. */
+    enableExport?: boolean;
+    /** Default export options. */
+    exportOptions?: ExportOptions;
+    /**
+     * 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 any cell on the grid is clicked - inspect the event to determine the column.
+     * Note that {@link ColumnSpec.onCellClicked} is a more targeted handler scoped to a single
+     * column, which might be more convenient when clicks on only one column are of interest.
+     */
+    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 strings (or a function returning one) providing user-facing labels for each depth
+     * level in a tree or grouped grid - e.g. `['Country', 'State', 'City']`. If set, the
+     * expand/collapse options in the default context menu will be enhanced to allow users to
+     * expand/collapse to a specific level. See {@link GroupingChooserModel.valueDisplayNames}
+     * for a convenient getter that will satisfy this API when a GroupingChooser is in play.
+     */
+    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 or false to omit context menu from grid.
+     */
+    contextMenu?: GridContextMenuSpec | false;
+    /**
+     * 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;
+    /** Default autosize options. */
+    autosizeOptions?: GridAutosizeOptions;
+    /** True to enable full row editing. Default false. */
+    fullRowEditing?: boolean;
+    /**
+     * Number of clicks required to begin inline-editing a cell. May be 2 (default) or 1 - any
+     * other value prevents user clicks from starting an edit.
+     */
+    clicksToEdit?: number;
+    /**
+     * 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;
+    /**
+     *  Set to true to ensure that the grid will have a single horizontal scrollbar spanning the
+     *  width of all columns, including any pinned columns.  A value of false (default) will show
+     *  the scrollbar only under the scrollable area.
+     */
+    enableFullWidthScroll?: 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?: GridExperimentalFlags;
+    /** Extra app-specific data for the GridModel. */
+    appData?: PlainObject;
+    /** @internal */
+    xhImpl?: boolean;
+}
+interface GridExperimentalFlags {
+    /**
+     * Set to true to enable more optimal row sorting in cases where only small subsets of rows are
+     * updated in configurations where rows have many siblings.
+     * See https://www.ag-grid.com/javascript-data-grid/grid-options/#reference-sort-deltaSort for
+     * more details on where this option may improve (or degrade) performance.
+     */
+    deltaSort?: boolean;
+    /**
+     * Set to true to disable scroll optimization for large grids, where we proactively update the
+     * row heights in ag-grid whenever the data changes to avoid hitching while quickly scrolling
+     * through large grids.
+     */
+    disableScrollOptimization?: boolean;
+}
+/**
+ * Core Model for a Grid, specifying the grid's data store, column definitions,
+ * sorting/grouping/selection state, and context menu configuration.
+ *
+ * This is the primary application entry-point for specifying Grid component options and behavior.
+ *
+ * This model also supports nested tree data. To show a tree:
+ *   1) Bind this model to a store with hierarchical records.
+ *   2) Set `treeMode: true` on this model.
+ *   3) Include a single column with `isTreeColumn: true`. This column will provide expand /
+ *      collapse controls and indent child columns in addition to displaying its own data.
+ *
+ */
+export declare class GridModel extends HoistModel {
+    static DEFAULT_RESTORE_DEFAULTS_WARNING: import("react").ReactElement<{
+        children?: ReactNode | undefined;
+    }, any>;
+    static DEFAULT_AUTOSIZE_MODE: GridAutosizeMode;
+    store: Store;
+    selModel: StoreSelectionModel;
+    treeMode: boolean;
+    colChooserModel: HoistModel;
+    rowClassFn: RowClassFn;
+    rowClassRules: Record<string, RowClassRuleFn>;
+    contextMenu: GridContextMenuSpec;
+    groupRowHeight: number;
+    groupRowRenderer: GroupRowRenderer;
+    groupSortFn: GridGroupSortFn;
+    showGroupRowCounts: boolean;
+    enableColumnPinning: boolean;
+    enableExport: boolean;
+    enableFullWidthScroll: boolean;
+    externalSort: boolean;
+    exportOptions: ExportOptions;
+    useVirtualColumns: boolean;
+    autosizeOptions: GridAutosizeOptions;
+    restoreDefaultsFn: () => Awaitable<void>;
+    restoreDefaultsWarning: ReactNode;
+    fullRowEditing: boolean;
+    hideEmptyTextBeforeLoad: boolean;
+    highlightRowOnClick: boolean;
+    clicksToExpand: number;
+    clicksToEdit: number;
+    lockColumnGroups: boolean;
+    headerMenuDisplay: 'always' | 'hover';
+    colDefaults: Partial<ColumnSpec>;
+    experimental: GridExperimentalFlags;
+    onKeyDown: (e: KeyboardEvent) => void;
+    onRowClicked: (e: RowClickedEvent) => void;
+    onRowDoubleClicked: (e: RowDoubleClickedEvent) => void;
+    onCellClicked: (e: CellClickedEvent) => void;
+    onCellDoubleClicked: (e: CellDoubleClickedEvent) => void;
+    onCellContextMenu: (e: CellContextMenuEvent) => void;
+    levelLabels: Thunkable<string[]>;
+    appData: PlainObject;
+    filterModel: GridFilterModel;
+    agGridModel: AgGridModel;
+    viewRef: RefObject<HTMLDivElement>;
+    columns: ColumnOrGroup[];
+    columnState: ColumnState[];
+    expandState: any;
+    sortBy: GridSorter[];
+    groupBy: string[];
+    expandLevel: number;
+    get persistableColumnState(): ColumnState[];
+    showSummary: boolean | VSide;
+    emptyText: ReactNode;
+    treeStyle: TreeStyle;
+    /**
+     * Flag to track inline editing at a granular level. Will toggle each time row
+     * or cell editing is activated or ended.
+     */
+    get isEditing(): boolean;
+    /**
+     * Flag to track inline editing at a general level.
+     * Will not change during transient navigation from cell to cell or row to row,
+     * but rather is debounced such that grid editing will need to "settle" for a
+     * short time before toggling.
+     */
+    isInEditingMode: boolean;
+    static defaultContextMenu: string[];
+    private editingCell;
+    private _defaultState;
+    /**
+     * Is autosizing enabled on this grid?
+     * To disable autosizing, set autosizeOptions.mode to GridAutosizeMode.DISABLED.
+     */
+    get autosizeEnabled(): boolean;
+    get maxDepth(): number;
+    get bodyViewport(): HTMLElement;
+    /** Tracks execution of filtering operations.*/
+    filterTask: TaskObserver;
+    /** Tracks execution of autosize operations. */
+    autosizeTask: TaskObserver;
+    constructor(config: GridConfig);
+    /**
+     * Restore the column, sorting, and grouping configs as specified by the application at
+     * construction time. This is the state without any saved grid state or 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>;
+    /**
+     * Export grid data using Hoist's server-side export.
+     *
+     * @param options - overrides of default export options to use for this export.
+     */
+    exportAsync(options?: ExportOptions): Promise<void>;
+    /**
+     * Export grid data using ag-Grid's built-in client-side export.
+     *
+     * @param filename - name for exported file.
+     * @param type - type of export - either 'excel' or 'csv'.
+     * @param params - passed to agGrid's export functions.
+     */
+    localExport(filename: string, type: 'excel' | 'csv', params?: PlainObject): void;
+    /**
+     * Select records in the grid.
+     * @param records - one or more record(s) / ID(s) to select.
+     * @param opts - additional post-selection options
+     */
+    selectAsync(records: Some<StoreRecordOrId>, opts?: {
+        /**
+         * True (default) to scroll the grid or expand nodes as needed to make selection
+         * visible if it is within a collapsed node or outside of the visible scroll window.
+         */
+        ensureVisible?: boolean;
+        /** True (default) to clear previous selection (rather than add to it). */
+        clearSelection?: boolean;
+    }): Promise<void>;
+    /**
+     * Select the first row in the grid.
+     *
+     * See {@link preSelectFirstAsync} for a useful variant of this method that will leave the
+     * any pre-existing selection unchanged, which is what apps typically want when reloading an
+     * already-populated grid.
+     */
+    selectFirstAsync(opts?: {
+        /**
+         * True (default) to expand nodes as needed to allow selection when the first selectable
+         * node is in a collapsed group.
+         */
+        expandParentGroups?: boolean;
+        /**
+         * True (default) to scroll the grid or expand nodes as needed to make selection
+         * visible if it is outside of the visible scroll window.
+         */
+        ensureVisible?: boolean;
+    }): Promise<void>;
+    /**
+     * Select the first row in the grid, if no other selection present.
+     * This method delegates to {@link selectFirstAsync}.
+     */
+    preSelectFirstAsync(): Promise<void>;
+    /** Deselect all rows. */
+    clearSelection(): void;
+    /**
+     * Scroll to ensure the selected record or records are visible.
+     *
+     * If multiple records are selected, scroll to the first record and then the last. This will do
+     * the minimum scrolling necessary to display the start of the selection and as much as
+     * possible of the rest.
+     *
+     * Any selected records that are hidden because their parent rows are collapsed will first
+     * be revealed by expanding their parent rows.
+     */
+    ensureSelectionVisibleAsync(): Promise<void>;
+    /**
+     * Scroll to ensure the provided record or records are visible.
+     *
+     * If multiple records are specified, scroll to the first record and then the last. This will do
+     * the minimum scrolling necessary to display the start of the provided record and as much as
+     * possible of the rest.
+     *
+     * Any provided records that are hidden because their parent rows are collapsed will first
+     * be revealed by expanding their parent rows.
+     *
+     * @param records - one or more record(s) for which to ensure visibility.
+     */
+    ensureRecordsVisibleAsync(records: Some<StoreRecord>): Promise<void>;
+    /** True if any records are selected. */
+    get hasSelection(): boolean;
+    /** Currently selected records. */
+    get selectedRecords(): StoreRecord[];
+    /** IDs of currently selected records. */
+    get selectedIds(): StoreRecordId[];
+    /**
+     * Single selected record, or null if multiple/no records selected.
+     *
+     * Note that this getter will also change if just the data of selected record is changed
+     * due to store loading or editing.  Applications only interested in the identity
+     * of the selection should use {@link selectedId} instead.
+     */
+    get selectedRecord(): StoreRecord;
+    /**
+     * ID of selected record, or null if multiple/no records selected.
+     *
+     * Note that this getter will *not* change if just the data of selected record is changed
+     * due to store loading or editing.  Applications also interested in the contents of the
+     * selection should use the {@link selectedRecord} getter instead.
+     */
+    get selectedId(): StoreRecordId;
+    /** True if this grid has no records to show in its store. */
+    get empty(): boolean;
+    get isReady(): boolean;
+    get agApi(): import("ag-grid-community").GridApi<any>;
+    get sizingMode(): SizingMode;
+    set sizingMode(v: SizingMode);
+    setSizingMode(v: SizingMode): void;
+    get showHover(): boolean;
+    set showHover(v: boolean);
+    setShowHover(v: boolean): void;
+    get rowBorders(): boolean;
+    set rowBorders(v: boolean);
+    setRowBorders(v: boolean): void;
+    get stripeRows(): boolean;
+    set stripeRows(v: boolean);
+    setStripeRows(v: boolean): void;
+    get cellBorders(): boolean;
+    set cellBorders(v: boolean);
+    setCellBorders(v: boolean): void;
+    get showCellFocus(): boolean;
+    set showCellFocus(v: boolean);
+    setShowCellFocus(v: boolean): void;
+    get hideHeaders(): boolean;
+    set hideHeaders(v: boolean);
+    setHideHeaders(v: boolean): void;
+    /**
+     * Apply full-width row-level grouping to the grid for the given column ID(s).
+     * This method will clear grid grouping if provided any ids without a corresponding column.
+     * @param colIds - ID(s) for row grouping, null to ungroup.
+     */
+    setGroupBy(colIds: Some<string>): void;
+    /** Expand all parent rows in grouped or tree grid. (Note, this is recursive for trees!) */
+    expandAll(): void;
+    /** Collapse all parent rows in grouped or tree grid. */
+    collapseAll(): void;
+    /** Expand all parent rows in grouped or tree grid to the specified level. */
+    expandToLevel(level: number): void;
+    /**
+     * Get the resolved level labels for the current state of the grid.
+     */
+    get resolvedLevelLabels(): string[];
+    /**
+     * Sort this grid.
+     * This method is a no-op if provided any sorters without a corresponding column.
+     */
+    setSortBy(sorters: Some<GridSorterLike>): void;
+    doLoadAsync(loadSpec: LoadSpec): Promise<any>;
+    /** Load the underlying store. */
+    loadData(rawData: any[], rawSummaryData?: Some<PlainObject>): void;
+    /** Update the underlying store. */
+    updateData(rawData: PlainObject[] | StoreTransaction): import("@xh/hoist/data").StoreChangeLog;
+    /** Clear the underlying store, removing all rows. */
+    clear(): void;
+    setColumns(colConfigs: ColumnOrGroupSpec[]): void;
+    setColumnState(colState: ColumnState[]): void;
+    showColChooser(): void;
+    noteAgColumnStateChanged(agColState: AgColumnState[]): void;
+    setExpandState(expandState: any): void;
+    noteAgExpandStateChange(): void;
+    noteAgSelectionStateChanged(): void;
+    noteColumnManuallySized(colId: any, width: any): void;
+    /**
+     * This method will update the current column definition if it has changed.
+     * Throws an exception if any of the columns provided in colStateChanges are not
+     * present in the current column list.
+     *
+     * Note: Column ordering is determined by the individual (leaf-level) columns in state.
+     * This means that if a column has been redefined to a new column group, that entire group may
+     * be moved to a new index.
+     *
+     * @param colStateChanges - changes to apply to the columns. If all leaf
+     *     columns are represented in these changes then the sort order will be applied as well.
+     */
+    updateColumnState(colStateChanges: Partial<ColumnState>[]): void;
+    /** @deprecated - use {@link updateColumnState} instead. */
+    applyColumnStateChanges(colStateChanges: Partial<ColumnState>[]): void;
+    getColumn(colId: string): Column;
+    getColumnGroup(groupId: string): ColumnGroup;
+    /** Return all leaf-level columns - i.e. excluding column groups. */
+    getLeafColumns(): Column[];
+    /** Return all leaf-level column ids - i.e. excluding column groups. */
+    getLeafColumnIds(): string[];
+    /** Return all currently-visible leaf-level columns. */
+    getVisibleLeafColumns(): Column[];
+    /**
+     * Determine whether or not a given leaf-level column is currently visible.
+     *
+     * Call this method instead of inspecting the `hidden` property on the Column itself, as that
+     * property is not updated with state changes.
+     */
+    isColumnVisible(colId: string): boolean;
+    setColumnVisible(colId: string, visible: boolean): void;
+    showColumn(colId: string): void;
+    hideColumn(colId: string): void;
+    setColumnGroupVisible(groupId: string, visible: boolean): void;
+    showColumnGroup(groupId: string): void;
+    hideColumnGroup(groupId: string): void;
+    /**
+     * Determine if a leaf-level column is currently pinned.
+     *
+     * Call this method instead of inspecting the `pinned` property on the Column itself, as that
+     * property is not updated with state changes.
+     */
+    getColumnPinned(colId: string): HSide;
+    /** Return matching leaf-level Column object from the provided collection. */
+    findColumn(cols: ColumnOrGroup[], colId: string): Column;
+    /** Return matching ColumnGroup from the provided collection. */
+    findColumnGroup(cols: ColumnOrGroup[], groupId: string): ColumnGroup;
+    /**
+     * Return the current state object representation for the given colId.
+     *
+     * Note that column state updates do not write changes back to the original Column object (as
+     * held in this model's `columns` collection), so this method should be called whenever the
+     * current value of any state-tracked property is required.
+     */
+    getStateForColumn(colId: string): ColumnState;
+    /**
+     * Autosize columns to fit their contents.
+     *
+     * This method will ignore columns with a flex value or with `autosizable: false`. Hidden
+     * columns are also ignored unless {@link GridAutosizeOptions.includeHiddenColumns} has been
+     * set to true.
+     *
+     * @param overrideOpts - optional overrides of this model's {@link GridAutosizeOptions}.
+     */
+    autosizeAsync(overrideOpts?: Omit<GridAutosizeOptions, 'mode'>): Promise<void>;
+    /**
+     * Begin an inline editing session.
+     * @param opts - options controlling which record/column to edit.
+     */
+    beginEditAsync(opts?: BeginEditAsyncOptions): Promise<void>;
+    /**
+     * Stop an inline editing session, if one is in-progress.
+     * @param dropPendingChanges - true to cancel current edit without saving pending
+     *      changes in the active editor(s) to the backing StoreRecord.
+     */
+    endEditAsync(dropPendingChanges?: boolean): Promise<void>;
+    /** @internal */
+    onCellEditingStarted: (e: CellEditingStartedEvent) => void;
+    /** @internal*/
+    onCellEditingStopped: (e: CellEditingStoppedEvent) => void;
+    /**
+     * Returns true as soon as the underlying agGridModel is ready, waiting a limited period
+     * of time if needed to allow the component to initialize. Returns false if grid not ready
+     * by end of timeout to ensure caller does not wait forever (if e.g. grid is not mounted).
+     * TODO - see https://github.com/xh/hoist-react/issues/2551 and note that calls to this method
+     *   within this class re-check `isReady` directly. We have observed this method returning
+     *   to its caller as true when the ag-grid/API has in fact dismounted and is no longer ready.
+     *
+     * This method will introduce a minimal delay for all calls.  This is useful to ensure
+     * that the grid has had the opportunity to process any pending data updates, which are also
+     * subject to a minimal async debounce.
+     *
+     * @param timeout - timeout in ms
+     */
+    whenReadyAsync(timeout?: number): Promise<boolean>;
+    /**
+     * Sorts ungrouped items to the bottom.
+     */
+    defaultGroupSortFn: (a: string, b: string) => number;
+    /** @internal */
+    get deltaSort(): boolean;
+    /** @internal */
+    get disableScrollOptimization(): boolean;
+    private buildColumn;
+    private autosizeColsInternalAsync;
+    private gatherLeaves;
+    private collectIds;
+    private formatValuesForExport;
+    private parseAndSetColumnsAndStore;
+    private validateColumns;
+    private cleanColumnState;
+    private enhanceColConfigsFromStore;
+    private enhanceStoreConfigFromColumns;
+    private leafColsByFieldName;
+    private parseSizingMode;
+    private parseSelModel;
+    private parseFilterModel;
+    private parseExperimental;
+    private parseChooserModel;
+    private isGroupSpec;
+    private readonly LEFT_BORDER_CLASS;
+    private readonly RIGHT_BORDER_CLASS;
+    private enhanceConfigWithGroupBorders;
+    private createGroupBorderFn;
+    private getDefaultStateForColumn;
+}
+/** Options for {@link GridModel.beginEditAsync}. */
+export interface BeginEditAsyncOptions {
+    /** StoreRecord/ID to edit. If unspecified, the first selected StoreRecord
+     *  will be used, if any, or the first overall StoreRecord in the grid. */
+    record?: StoreRecordOrId;
+    /** ID of column on which to start editing. If unspecified, the first
+     *  editable column will be used. */
+    colId?: string;
+}
+export {};

package/build/types/cmp/grid/GridSorter.d.ts

@@ -0,0 +1,23 @@
+export type GridSorterLike = GridSorterSpec | string | GridSorter;
+export interface GridSorterSpec {
+    colId: string;
+    sort?: 'asc' | 'desc' | 'ASC' | 'DESC';
+    abs?: boolean;
+}
+export declare class GridSorter {
+    readonly colId: string;
+    readonly sort: 'asc' | 'desc';
+    readonly abs: boolean;
+    /**
+     * Create a new GridSorter. Accepts a GridSorter configuration or a pipe delimited string
+     * generated using GridSorter.toString().
+     */
+    static parse(cfg: GridSorterLike): GridSorter;
+    constructor(spec: GridSorterSpec);
+    /** Generate a delimited string representation suitable for consumption by parse().*/
+    toString(): string;
+    /** Comparator to use with instances of GridSorter.*/
+    comparator(v1: any, v2: any): number;
+    /** Static comparator to use when a GridSorter instance is not available.*/
+    static defaultComparator(v1: any, v2: any): number;
+}