@xh/hoist 82.0.1 → 82.0.3

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

@@ -0,0 +1,285 @@
+import type { HSide, PersistOptions, Some } from '@xh/hoist/core';
+import type { FilterBindTarget, FilterMatchMode, FilterValueSource, Store, StoreRecord } from '@xh/hoist/data';
+import type { CellClassParams, CustomCellEditorProps, HeaderClassParams, HeaderValueGetterParams, ICellRendererParams, IRowNode, ITooltipParams, RowClassParams, ValueSetterParams } from '@xh/hoist/kit/ag-grid';
+import type { ReactElement, ReactNode } from 'react';
+import type { Column, ColumnSpec } from './columns/Column';
+import type { ColumnGroup, ColumnGroupSpec } from './columns/ColumnGroup';
+import type { GridFilterFieldSpecConfig } from './filter/GridFilterFieldSpec';
+import type { GridModel } from './GridModel';
+export interface ColumnState {
+    colId: string;
+    width: number;
+    hidden: boolean;
+    /** has this column been resized manually? */
+    manuallySized?: boolean;
+    /** Side if pinned, null if not. */
+    pinned?: HSide;
+}
+/**
+ * Comparator for custom grid group sorting, provided to GridModel.
+ * @param groupAVal - first group value to be compared.
+ * @param groupBVal - second group value to be compared.
+ * @param groupField - field name being grouped at this level.
+ * @param metadata - additional metadata with raw ag-Grid group nodes.
+ * @returns 0 if group values are equal, a negative number if `a` sorts first,
+ *      and a positive number if `b` sorts first.
+ */
+export type GridGroupSortFn = (groupAVal: string, groupBVal: string, groupField: string, metadata: {
+    gridModel: GridModel;
+    nodeA: IRowNode;
+    nodeB: IRowNode;
+}) => number;
+/**
+ * Closure to generate CSS class names for a row.
+ * @param record - the StoreRecord associated with the rendered row.
+ * @returns CSS class(es) to apply to the row level.
+ */
+export type RowClassFn = (record: StoreRecord) => Some<string>;
+/**
+ * Function to determine if a particular CSS class should be added/removed from a row,
+ * via rowClassRules config.
+ * @param agParams - as provided by AG-Grid.  Note that when a RowClassRuleFn is called by the
+ *      GridAutosizeService, it is only provided with an object with the 'data' key,
+ *      not the entire RowClassParams params.
+ * @returns true if the class to which this function is keyed should be added, false if
+ *      it should be removed.
+ */
+export type RowClassRuleFn = (agParams: RowClassParams) => boolean;
+export interface GridModelPersistOptions extends PersistOptions {
+    /** True (default) to include column state or provide column-specific PersistOptions. */
+    persistColumns?: boolean | PersistOptions;
+    /** True (default) to include grouping state or provide grouping-specific PersistOptions. */
+    persistGrouping?: boolean | PersistOptions;
+    /** True (default) to include sort state or provide sort-specific PersistOptions. */
+    persistSort?: boolean | PersistOptions;
+    /** True (default) to include expanded level state or provide expanded level-specific PersistOptions.  */
+    persistExpandToLevel?: boolean | PersistOptions;
+}
+export interface GridFilterModelConfig {
+    /**
+     * Target (typically a {@link Store} or Cube {@link View}) to be filtered as column filters
+     * are applied and used as a source for unique values displayed in the filtering UI when
+     * applicable. Defaulted to the gridModel's store.
+     */
+    bind?: GridFilterBindTarget;
+    /**
+     * True to update filters immediately after each change made in the column-based filter UI.
+     * Defaults to False.
+     */
+    commitOnChange?: boolean;
+    /**
+     * Specifies the fields this model supports for filtering. Should be configs for
+     * {@link GridFilterFieldSpec}, string names to match with Fields in bound Store/View, or
+     * omitted entirely to indicate that all fields should be filter-enabled.
+     */
+    fieldSpecs?: Array<string | GridFilterFieldSpecConfig>;
+    /** Default properties to be assigned to all fieldSpecs created by this model. */
+    fieldSpecDefaults?: Omit<GridFilterFieldSpecConfig, 'field'>;
+}
+/**
+ * {@link GridFilterModel} currently accepts a single `bind` target that also provides available
+ * values. Note that both `Store` and `View` satisfy this intersection.
+ */
+export interface GridFilterBindTarget extends FilterBindTarget, FilterValueSource {
+}
+/**
+ * Renderer for a group row
+ * @param context - The group renderer params from ag-Grid
+ * @returns the formatted value for display.
+ */
+export type GroupRowRenderer = (context: ICellRendererParams) => ReactNode;
+export interface ColChooserConfig {
+    /** GridModel to bind to. Not required if creating via `GridModel.colChooserModel` */
+    gridModel?: GridModel;
+    /**
+     * Immediately render changed columns on grid (default true).
+     * Set to false to enable Save button for committing changes on save. Desktop only.
+     */
+    commitOnChange?: boolean;
+    /**
+     * Show Restore Defaults button (default true). Set to false to hide Restore Grid
+     * Defaults button, which immediately commits grid defaults (all column, grouping,
+     * and sorting states).
+     */
+    showRestoreDefaults?: boolean;
+    /**
+     * Autosize grid columns after committing changes (default false for desktop, true for mobile).
+     */
+    autosizeOnCommit?: boolean;
+    /** Chooser width for popover and dialog. Desktop only. */
+    width?: string | number;
+    /** Chooser height for popover and dialog. Desktop only. */
+    height?: string | number;
+    /** Mode to use when filtering (default 'startWord'). Desktop only. */
+    filterMatchMode?: FilterMatchMode;
+}
+export type ColumnOrGroup = Column | ColumnGroup;
+export type ColumnOrGroupSpec = ColumnSpec | ColumnGroupSpec;
+export declare function isColumnSpec(spec: ColumnOrGroupSpec): spec is ColumnSpec;
+/**
+ * Sort comparator function for a grid column. Note that this comparator will also be called if
+ * agGrid-provided column filtering is enabled: it is used to sort values shown for set filter
+ * options. In that case, some extra params will be null.
+ * @param valueA - cell data valueA to be compared
+ * @param valueB - cell data valueB to be compared
+ * @param sortDir - either 'asc' or 'desc'
+ * @param abs - true to sort by absolute value
+ * @param params - additional context about records and column for usage by comparator.
+ */
+export type ColumnComparator<T = any> = (valueA: T, valueB: T, sortDir: 'asc' | 'desc', abs: boolean, params: {
+    recordA: StoreRecord;
+    recordB: StoreRecord;
+    agNodeA: IRowNode;
+    agNodeB: IRowNode;
+    column: Column;
+    gridModel: GridModel;
+    defaultComparator: (a: T, b: T) => number;
+}) => number;
+export interface CellContext {
+    record: StoreRecord;
+    column: Column;
+    gridModel: GridModel;
+}
+/**
+ * Renderer function for a grid cell.
+ * @param value - cell data value (column + row).
+ * @param context - additional data about the column, row and GridModel.
+ *      Note that columns with renderers that access/rely on record fields other than the primary
+ *      value should also have their `rendererIsComplex` flag set to true to ensure they are
+ *      re-run whenever the record (and not just the primary value) changes.
+ * @returns the formatted value for display.
+ */
+export type ColumnRenderer<T = any> = (value: T, context: CellContext) => ReactNode;
+/**
+ * Function to return a value to export for a grid cell.
+ * @param value - cell data value (column + row).
+ * @param context - additional data about the column, row and GridModel.
+ * @returns value for export.
+ */
+export type ColumnExportValueFn<T = any> = (value: T, context: CellContext) => any;
+/**
+ * Function to return an excel format for a grid cell.
+ * @param value - cell data value (column + row).
+ * @param context - additional data about the column, row and GridModel.
+ * @returns excel format
+ */
+export type ColumnExcelFormatFn<T = any> = (value: T, context: CellContext) => string;
+/**
+ * Function to return a value for sorting.
+ * @param value - cell data value (column + row).
+ * @param context - additional data about the column, row and GridModel.
+ * @returns value for sort.
+ */
+export type ColumnSortValueFn<T = any> = (value: T, context: CellContext) => any;
+/**
+ * Function to generate grid cell CSS classes.
+ * @param value - cell data value (column + row).
+ * @param context - additional data about the column, row and GridModel.
+ * @returns CSS class(es) to use.
+ */
+export type ColumnCellClassFn<T = any> = (value: T, context: CellContext & {
+    agParams: CellClassParams;
+}) => Some<string>;
+/**
+ * Function to determine if a particular CSS class should be added/removed from a cell, via
+ * cellClassRules config.
+ * @param agParams - as provided by Ag-Grid.  Includes keys:
+ *      value - the current cell value.
+ *      data - the backing Hoist record for the row, if any.
+ * @returns true if the class to which this function is keyed should be added, false if
+ *      it should be removed.
+ */
+export type ColumnCellClassRuleFn = (agParams: CellClassParams) => boolean;
+/**
+ * Function to produce a grid column tooltip.
+ * @param value - cell data value (column + row).
+ * @param metadata - additional data about the column and row.
+ * @returns the formatted value for display.
+ */
+export type ColumnTooltipFn<T = any> = (value: T, cellContext: CellContext & {
+    agParams: ITooltipParams;
+}) => ReactNode;
+/**
+ * Function to generate header CSS classes.
+ * @param context - contains data about the column and GridModel.
+ * @returns CSS class(es) to use.
+ */
+export type ColumnHeaderClassFn = (context: {
+    column: ColumnOrGroup;
+    gridModel: GridModel;
+    agParams: HeaderClassParams;
+}) => Some<string>;
+/**
+ * Function to generate a Column header name.
+ * Note that using function for the header name will ignore any ag-Grid functionality for
+ * decorating the header name, the return value of the function will be used as-is.
+ * The function should be treated like an autorun - any subsequent changes to observable properties
+ * referenced during the previous execution of the function will trigger a re-render
+ * of the column header.
+ *
+ * @returns the header name to render in the Column header
+ */
+export type ColumnHeaderNameFn = (params: {
+    column?: Column;
+    columnGroup?: ColumnGroup;
+    gridModel: GridModel;
+    agParams: HeaderValueGetterParams;
+}) => ReactNode;
+/**
+ * Function to determine if a Column should be editable or not. This function will be
+ * called whenever the user takes some action which would initiate inline editing of a cell
+ * before the actual inline editing session is started.
+ * @returns true if cell is editable
+ */
+export type ColumnEditableFn = (params: {
+    record: StoreRecord;
+    store: Store;
+    column: Column;
+    gridModel: GridModel;
+}) => boolean;
+/**
+ * Function to return one Grid cell editor. This function will be used to create a new
+ * Component, whenever editing is initiated on a cell.
+ * The never parameter is never provided - it is included to satisfy typescript. See
+ * discussion in https://github.com/xh/hoist-react/pull/3351.
+ * @returns the react element to use as the cell editor.
+ */
+export type ColumnEditorFn = (props: ColumnEditorProps, never?: any) => ReactElement;
+/**
+ * The object passed into the first argument of {@link ColumnSpec.editor}.
+ * Satisfies the {@link EditorProps} of an editor component.
+ */
+export type ColumnEditorProps = {
+    record: StoreRecord;
+    column: Column;
+    gridModel: GridModel;
+    agParams: CustomCellEditorProps;
+};
+/**
+ * Function to update the value of a StoreRecord field after inline editing
+ */
+export type ColumnSetValueFn<T = any> = (params: {
+    value: T;
+    record: StoreRecord;
+    field: string;
+    store: Store;
+    column: Column;
+    gridModel: GridModel;
+    agParams: ValueSetterParams;
+}) => void;
+/**
+ * Function to get the value of a StoreRecord field
+ */
+export type ColumnGetValueFn<T = any> = (params: {
+    record: StoreRecord;
+    field: string;
+    store: Store;
+    column: Column;
+    gridModel: GridModel;
+}) => T;
+export interface ColumnSortSpec {
+    /** Direction to sort, either 'asc' or 'desc', or null to remove sort. */
+    sort: 'asc' | 'desc' | null;
+    /** True to sort by absolute value. */
+    abs?: boolean;
+}

package/build/types/cmp/grid/columns/Column.d.ts

@@ -0,0 +1,380 @@
+import { HAlign, HSide, PlainObject, Some, Thunkable } from '@xh/hoist/core';
+import { CubeFieldSpec, FieldSpec, RecordAction, RecordActionSpec, StoreRecord } from '@xh/hoist/data';
+import { FunctionComponent, ReactNode } from 'react';
+import { GridModel } from '../GridModel';
+import { ColumnCellClassFn, ColumnCellClassRuleFn, ColumnComparator, ColumnEditableFn, ColumnEditorFn, ColumnEditorProps, ColumnExcelFormatFn, ColumnExportValueFn, ColumnGetValueFn, ColumnHeaderClassFn, ColumnHeaderNameFn, ColumnRenderer, ColumnSetValueFn, ColumnSortSpec, ColumnSortValueFn, ColumnTooltipFn } from '../Types';
+import type { ColDef, CellClickedEvent } from '@xh/hoist/kit/ag-grid';
+export interface ColumnSpec {
+    /**
+     * Name of data store field to display within the column, or object containing properties
+     * for store field.  If object form is used, the provided properties will be used for
+     * auto-creating any fields needed on the Grid's store.
+     */
+    field?: string | FieldSpec | CubeFieldSpec;
+    /**
+     * Unique identifier for the Column within its grid. Defaults to field name - one of these
+     * two properties must be specified.
+     */
+    colId?: string;
+    /**
+     * True if this column will host the expand/collapse arrow controls for a hierarchical
+     * Tree Grid. For when `GridModel.treeMode` is enabled, one column in that grid should have
+     * this flag enabled.
+     */
+    isTreeColumn?: boolean;
+    /**
+     * Primary user-facing name for this Column. Sourced from the corresponding data
+     * `Field.displayName` from the parent `GridModel.store` config, if available, or defaulted
+     * via transform of `field` string config. Used as default value for more specialized
+     * `headerName`, `chooserName`, and `exportName` configs. See those configs for additional
+     * details and options they support.
+     */
+    displayName?: string;
+    /**
+     * Supplementary descriptive text for this Column. Sourced from the corresponding data
+     * `Field.description` if available. Used as the default value for `headerTooltip` and
+     * `chooserDescription` when those are not explicitly set.
+     */
+    description?: string;
+    /**
+     * User-facing text/element displayed in the Column header, or a function to produce the same.
+     * Defaulted from `displayName`.
+     */
+    headerName?: ColumnHeaderNameFn | ReactNode;
+    /** Tooltip text for grid header. Defaults from `description` when not explicitly set. */
+    headerTooltip?: string;
+    /**
+     * True if this column header will host an expand/collapse all icon. `Column.isTreeColumn`
+     * must be enabled. Defaults to true.
+     */
+    headerHasExpandCollapse?: boolean;
+    /** Horizontal alignment of header contents. Defaults to same as cell alignment. */
+    headerAlign?: HAlign;
+    /** CSS classes to add to the header. Supports both string values or a function to generate strings.*/
+    headerClass?: ColumnHeaderClassFn | Some<string>;
+    /**
+     * Additional CSS classes to add to each cell in the column. Supports both string values or
+     * function to generate.NOTE that, once added, classes will *not* be removed if the data changes.
+     * Use `cellClassRules` instead if StoreRecord data can change across refreshes
+     */
+    cellClass?: ColumnCellClassFn | Some<string>;
+    /**
+     * CSS class names to functions determining if they should be added or removed from the cell.
+     * See Ag-Grid docs on "cell styles" for details.
+     */
+    cellClassRules?: Record<string, ColumnCellClassRuleFn>;
+    /** True to suppress default display of the column.*/
+    hidden?: boolean;
+    /**
+     * Flex columns stretch to fill the width of the grid after all columns with a set pixel-width
+     * have been sized. If multiple columns have a flex value set, their width will be set in
+     * proportion to their flex values. A flex value of `true` is equivalent to 1. Consider pairing
+     * a flex setting with min/max pixel widths to avoid your column being squeezed down to the
+     * default 50px minimum or stretching so wide that it compromises the overall legibility of
+     * the grid.
+     */
+    flex?: boolean | number;
+    /** Default width in pixels.*/
+    width?: number;
+    /**
+     * Minimum width in pixels - grid will block user-driven as well as auto-flex resizing below
+     * this value. (Note this is *not* a substitute for width.)
+     */
+    minWidth?: number;
+    /**
+     * Maximum width in pixels - grid will block user-driven as well as auto-flex resizing above
+     * this value.
+     */
+    maxWidth?: number;
+    /**
+     * Row height required by column in pixels - grids can use this to determine an appropriate
+     * row height when the column is visible.
+     */
+    rowHeight?: number;
+    /** Horizontal alignment of cell contents. Default is 'left'. */
+    align?: HAlign;
+    /**
+     * The sorting options for this column to be applied by successive clicks on the column header.
+     * Specify null to clear the sort on this column.
+     */
+    sortingOrder?: Array<'asc' | 'desc' | ColumnSortSpec | null>;
+    /**
+     * True to enable absolute value sorting for this column.  If false (default) absolute value
+     * sorts will be ignored when cycling through the sortingOrder.
+     */
+    absSort?: boolean;
+    /**
+     * Alternate field name to reference or function to call when producing a value for this column
+     * to be sorted by.
+     */
+    sortValue?: string | ColumnSortValueFn;
+    /**
+     * Values to match or functions to check to determine if a value should always be sorted
+     * to the bottom, regardless of sort order. If more than one entry is provided, values will be
+     * sorted according to the order they appear here.
+     */
+    sortToBottom?: Some<unknown | ((v: unknown) => boolean)>;
+    /** Function to compare cell values for sorting.*/
+    comparator?: ColumnComparator;
+    /** False to prevent user from drag-and-drop resizing. */
+    resizable?: boolean;
+    /** false to prevent user from sorting on this column. */
+    sortable?: boolean;
+    /** False to prevent user from drag-and-drop re-ordering. */
+    movable?: boolean;
+    /**
+     * True to enable an Excel-like column header filter menu. Menu option defaults vary based
+     * on the underlying Field.type, but include a checkbox-list "values filter" and a custom
+     * input filter for more complex queries.
+     */
+    filterable?: boolean;
+    /**
+     * False to always show column. Will appear in column chooser but always locked in the
+     * displayed collection of columns.
+     */
+    hideable?: boolean;
+    /**
+     * Set to true/'left' or 'right' to pin (aka "lock") the column to the side of the grid,
+     * ensuring it's visible while horizontally scrolling.
+     */
+    pinned?: boolean | HSide;
+    /** Function returning a React Element for each cell value in this Column.*/
+    renderer?: ColumnRenderer;
+    /**
+     * True if this renderer relies on more than just the value of the field associated with this
+     * column. Set to true to ensure that the cells for this column are updated any time the
+     * record is changed, but note this can negatively affect update performance. Default false.
+     */
+    rendererIsComplex?: boolean;
+    /**
+     * Set to true to call attention to cell changes by flashing the cell's background color.
+     */
+    highlightOnChange?: boolean;
+    /**
+     * True to display raw value, or tooltip function.
+     */
+    tooltip?: boolean | ColumnTooltipFn;
+    /**
+     * Name to display within the column chooser component. Defaults to `displayName`, can be
+     * longer / less abbreviated than `headerName` might be.
+     */
+    chooserName?: string;
+    /**
+     * Group name to display within the column chooser component.  Chooser will automatically group
+     * its "available columns" grid if any cols provide.
+     */
+    chooserGroup?: string;
+    /**
+     * Additional descriptive text to display within the column chooser. Appears when the column
+     * is selected within the chooser UI. Defaults from `description` when not explicitly set.
+     */
+    chooserDescription?: string;
+    /**
+     * True to hide the column from the column chooser completely. Useful for hiding
+     * structural columns the user is not expected to adjust.
+     */
+    excludeFromChooser?: boolean;
+    /**
+     * Name to use as a header within a file export. Defaults to `headerName`. Useful when
+     * `headerName` contains markup or other characters not suitable for use within an Excel or
+     * CSV file header.
+     */
+    exportName?: string | ColumnHeaderNameFn;
+    /**
+     * Alternate field name to reference or function to call when producing a value for a file
+     * export. {@link GridExportService}
+     */
+    exportValue?: string | ColumnExportValueFn;
+    /** True to drop this column from a file export. */
+    excludeFromExport?: boolean;
+    /** Structured format string for Excel-based exports, or a function to produce one. {@link ExcelFormat} */
+    excelFormat?: string | ColumnExcelFormatFn;
+    /**
+     * Width in characters for Excel-based exports. Typically used with ExcelFormat.LONG_TEXT to
+     * enable text wrapping.
+     */
+    excelWidth?: number;
+    /** Allow autosizing this column.*/
+    autosizable?: boolean;
+    /** True to include the header width when autosizing. */
+    autosizeIncludeHeader?: boolean;
+    /** True to always include the width of the sort icon when calculating the header width.*/
+    autosizeIncludeHeaderIcons?: boolean;
+    /** Minimum width in pixels when autosizing.*/
+    autosizeMinWidth?: number;
+    /** Maximum width in pixels when autosizing.*/
+    autosizeMaxWidth?: number;
+    /**
+     * Additional pixels to add to the size of each column beyond its absolute minimum. If
+     * specified, it will override the value of `GridAutosizeOptions.bufferPx` which is applied
+     * to all columns.
+     */
+    autosizeBufferPx?: number;
+    /**
+     * True to dynamically grow the row height based on the content of this column's cell.  If
+     * true, text will also be set to wrap within cells.
+     */
+    autoHeight?: boolean;
+    /**
+     * True to make cells in this column editable, or a function to determine on a
+     * record-by-record basis.
+     */
+    editable?: boolean | ColumnEditableFn;
+    /**
+     * Cell editor Component or a function to create one. Adding an editor will also install a
+     * cellClassRule and tooltip to display the validation state of the cell in question.
+     */
+    editor?: FunctionComponent<ColumnEditorProps> | ColumnEditorFn;
+    /**
+     * True if this cell editor should be rendered as a popup over the cell instead of within the
+     * actual cell element. Popup editors will have their width set to match the cell by default.
+     * Typically used with textarea cell editors.
+     */
+    editorIsPopup?: boolean;
+    /** Function for updating StoreRecord field for this column after inline editing. */
+    setValueFn?: ColumnSetValueFn;
+    /** Function for getting the column value. */
+    getValueFn?: ColumnGetValueFn;
+    /**
+     * True (default) to enable configuration of field name as a dot-separated path - e.g.
+     * `'country.name'` - where the default `getValueFn` will expect the field to be an object and
+     * render a nested property.  False to support field names that contain dots *without*
+     * triggering this behavior.
+     */
+    enableDotSeparatedFieldPath?: boolean;
+    /** True to skip this column when adding to grid. */
+    omit?: Thunkable<boolean>;
+    /**
+     * Actions to display as clickable buttons in this column. For action columns only.
+     */
+    actions?: Array<RecordActionSpec | RecordAction>;
+    /**
+     * For action columns, hide the Buttons for all rows except the currently hovered row. This can
+     * be a used to avoid overloading the user's attention with a wall of buttons when there are
+     * many rows + multiple actions per row. Defaults to false;
+     */
+    actionsShowOnHoverOnly?: boolean;
+    /**
+     * Callback when a cell within this column clicked.
+     * See also {@link GridConfig.onCellClicked}, called when any cell within the grid is clicked.
+     */
+    onCellClicked?: (e: CellClickedEvent) => void;
+    /**
+     * "escape hatch" object to pass directly to Ag-Grid for desktop implementations. Note these
+     * options may be used / overwritten by the framework itself, and are not all guaranteed to be
+     * compatible with its usages of Ag-Grid.
+     * See {@link https://www.ag-grid.com/javascript-grid-column-properties/|AG-Grid docs}
+     */
+    agOptions?: ColDef;
+    /** Extra, app-specific data for the column. */
+    appData?: PlainObject;
+}
+/**
+ * Cross-platform definition and API for a standardized Grid column.
+ * Provided to GridModels as plain configuration objects.
+ */
+export declare class Column {
+    static DEFAULT_WIDTH: number;
+    static FLEX_COL_MIN_WIDTH: number;
+    /**
+     * A convenience sort order. Default for non-numeric, non-date columns.
+     */
+    static ASC_FIRST: ColumnSortSpec[];
+    /**
+     * A convenience sort order. Default for numeric and date columns.
+     */
+    static DESC_FIRST: ColumnSortSpec[];
+    /**
+     * A convenience sort order. Default for numeric and date columns where absSort: true.
+     */
+    static ABS_DESC_FIRST: ColumnSortSpec[];
+    field: string;
+    enableDotSeparatedFieldPath: boolean;
+    fieldPath: Some<string>;
+    colId: string;
+    isTreeColumn: boolean;
+    displayName: string;
+    description: string;
+    headerName: ColumnHeaderNameFn | ReactNode;
+    headerTooltip: string;
+    headerHasExpandCollapse: boolean;
+    headerAlign: HAlign;
+    headerClass: ColumnHeaderClassFn | Some<string>;
+    cellClass: ColumnCellClassFn | Some<string>;
+    cellClassRules: Record<string, ColumnCellClassRuleFn>;
+    align: HAlign;
+    hidden: boolean;
+    flex: boolean | number;
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+    rowHeight: number;
+    sortingOrder: ColumnSortSpec[];
+    absSort: boolean;
+    sortValue: string | ColumnSortValueFn;
+    sortToBottom: Array<(v: unknown) => boolean>;
+    comparator: ColumnComparator;
+    resizable: boolean;
+    sortable: boolean;
+    movable: boolean;
+    filterable: boolean;
+    hideable: boolean;
+    pinned: HSide;
+    renderer: ColumnRenderer;
+    rendererIsComplex: boolean;
+    highlightOnChange: boolean;
+    tooltip: boolean | ColumnTooltipFn;
+    chooserName: string;
+    chooserGroup: string;
+    chooserDescription: string;
+    excludeFromChooser: boolean;
+    exportName: string | ColumnHeaderNameFn;
+    exportValue: string | ColumnExportValueFn;
+    excludeFromExport: boolean;
+    excelFormat: string | ColumnExcelFormatFn;
+    excelWidth: number;
+    autosizable: boolean;
+    autosizeIncludeHeader: boolean;
+    autosizeIncludeHeaderIcons: boolean;
+    autosizeMinWidth: number;
+    autosizeMaxWidth: number;
+    autosizeBufferPx: number;
+    autoHeight: boolean;
+    editable: boolean | ColumnEditableFn;
+    editor: FunctionComponent<ColumnEditorProps> | ColumnEditorFn;
+    editorIsPopup: boolean;
+    setValueFn: ColumnSetValueFn;
+    getValueFn: ColumnGetValueFn;
+    actions?: Array<RecordActionSpec | RecordAction>;
+    actionsShowOnHoverOnly?: boolean;
+    fieldSpec: FieldSpec;
+    omit: Thunkable<boolean>;
+    onCellClicked?: (e: CellClickedEvent) => void;
+    gridModel: GridModel;
+    agOptions: ColDef;
+    appData: PlainObject;
+    /**
+     * Not for application use. Columns are created internally by Hoist.
+     * Applications specify columns by providing ColumnSpec objects to the
+     * GridModel API.
+     *
+     * @internal
+     */
+    constructor(spec: ColumnSpec, gridModel: GridModel);
+    /** Does column support editing its field for the given StoreRecord? */
+    isEditableForRecord(record: StoreRecord): boolean;
+    /** A Column definition appropriate for AG-Grid. */
+    getAgSpec(): ColDef;
+    private defaultComparator;
+    private sortToBottomComparator;
+    private defaultSetValueFn;
+    defaultGetValueFn: ({ record }: {
+        record: any;
+    }) => any;
+    private parseField;
+    private parsePinned;
+    private parseSortingOrder;
+    private parseSortToBottom;
+    private parseFilterable;
+    private getSortValue;
+}