Column

This page refers to the table's column objects that are generated within the table instance. Refer to this link for the column definitions API.

The Column types are organized by feature. All feature types are ultimately joined in the single Column type definition.

API

CoreColumn

Basic column properties available on all columns regardless of features enabled. Includes column identification (id), hierarchy information (depth, parent), and references to associated rows and column definitions.

PropType
The resolved accessor function to use when extracting the value for the column from each row. Will only be defined if the column def has a valid accessor key or function defined.
    (
    originalRow: TData,
    index: number,
    ) => TValue
    The original column def used to create the column.
    ColumnDef<
    TData,
    TValue,
    TColumnMeta
    >
    The child column (if the column is a group column). Will be an empty array if the column is not a group column.
    Column<
    TData,
    TValue
    >[]
    The depth of the column (if grouped) relative to the root column def array.
    number
    Returns the flattened array of this column and all child/grand-child columns for this column.
        () => Column<
        TData,
        TValue
        >[]
        Returns an array of all leaf-node columns for this column. If a column has no children, it is considered the only leaf-node column.
            () => Column<
            TData,
            TValue
            >[]
            The resolved unique identifier for the column resolved in this priority:
            - A manual
            id property from the column def
            - The accessor key from the column def
            - The header string from the column def
            string
            The parent column for this column. Will be undefined if this is a root column.
            Column<
            TData,
            TValue
            >
            Type
            (
            originalRow: TData,
            index: number,
            ) => TValue
            Description
            The resolved accessor function to use when extracting the value for the column from each row. Will only be defined if the column def has a valid accessor key or function defined.
              Type
              ColumnDef<
              TData,
              TValue,
              TColumnMeta
              >
              Description
              The original column def used to create the column.
              Type
              Column<
              TData,
              TValue
              >[]
              Description
              The child column (if the column is a group column). Will be an empty array if the column is not a group column.
              Type
              number
              Description
              The depth of the column (if grouped) relative to the root column def array.
              Type
              () => Column<
              TData,
              TValue
              >[]
              Description
              Returns the flattened array of this column and all child/grand-child columns for this column.
                  Type
                  () => Column<
                  TData,
                  TValue
                  >[]
                  Description
                  Returns an array of all leaf-node columns for this column. If a column has no children, it is considered the only leaf-node column.
                      Type
                      string
                      Description
                      The resolved unique identifier for the column resolved in this priority:
                      - A manual
                      id property from the column def
                      - The accessor key from the column def
                      - The header string from the column def
                      Type
                      Column<
                      TData,
                      TValue
                      >
                      Description
                      The parent column for this column. Will be undefined if this is a root column.

                      FiltersColumn

                      Properties and methods for filtering column data. Provides access to filter functions, filter values, and methods to apply or clear filters. See the Column Filtering guide for implementation details.

                      PropType
                      Returns an automatically calculated filter function for the column based off of the columns first known value.
                          () =>
                          | FilterFn<TData>
                          | undefined
                          Returns whether the column can be column filtered.
                              () => boolean
                              Returns whether the column can be globally filtered. Set to false to disable a column from being scanned during global filtering.
                                  () => boolean
                                  A function that computes and returns a min/max tuple derived from getFacetedRowModel. Useful for displaying faceted result values. > ⚠️ Requires that you pass a valid getFacetedMinMaxValues function to options.getFacetedMinMaxValues. A default implementation is provided via the exported getFacetedMinMaxValues function.
                                      () =>
                                      | [number, number]
                                      | undefined
                                      Returns the row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.️ Requires that you pass a valid getFacetedRowModel function to options.facetedRowModel. A default implementation is provided via the exported getFacetedRowModel function.
                                          () => RowModel<TData>
                                          A function that computes and returns a Map of unique values and their occurrences derived from column.getFacetedRowModel. Useful for displaying faceted result values. Requires that you pass a valid getFacetedUniqueValues function to options.getFacetedUniqueValues. A default implementation is provided via the exported getFacetedUniqueValues function.
                                              () => Map<
                                              any,
                                              number
                                              >
                                              Returns the filter function (either user-defined or automatic, depending on configuration) for the columnId specified.
                                                  () =>
                                                  | FilterFn<TData>
                                                  | undefined
                                                  Returns the index of the column filter in the table's state.columnFilters array. Returns -1 if not found.
                                                      () => number
                                                      Returns the current filter value for the column.
                                                          () => unknown
                                                          Returns whether the column is currently filtered.
                                                              () => boolean
                                                              A function that sets the current filter value for the column. You can pass it a value or an updater function for immutability-safe operations on existing values.
                                                                  (
                                                                  updater: any,
                                                                  ) => void
                                                                  Type
                                                                  () =>
                                                                  | FilterFn<TData>
                                                                  | undefined
                                                                  Description
                                                                  Returns an automatically calculated filter function for the column based off of the columns first known value.
                                                                      Type
                                                                      () => boolean
                                                                      Description
                                                                      Returns whether the column can be column filtered.
                                                                          Type
                                                                          () => boolean
                                                                          Description
                                                                          Returns whether the column can be globally filtered. Set to false to disable a column from being scanned during global filtering.
                                                                              Type
                                                                              () =>
                                                                              | [number, number]
                                                                              | undefined
                                                                              Description
                                                                              A function that computes and returns a min/max tuple derived from getFacetedRowModel. Useful for displaying faceted result values. > ⚠️ Requires that you pass a valid getFacetedMinMaxValues function to options.getFacetedMinMaxValues. A default implementation is provided via the exported getFacetedMinMaxValues function.
                                                                                  Type
                                                                                  () => RowModel<TData>
                                                                                  Description
                                                                                  Returns the row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.️ Requires that you pass a valid getFacetedRowModel function to options.facetedRowModel. A default implementation is provided via the exported getFacetedRowModel function.
                                                                                      Type
                                                                                      () => Map<
                                                                                      any,
                                                                                      number
                                                                                      >
                                                                                      Description
                                                                                      A function that computes and returns a Map of unique values and their occurrences derived from column.getFacetedRowModel. Useful for displaying faceted result values. Requires that you pass a valid getFacetedUniqueValues function to options.getFacetedUniqueValues. A default implementation is provided via the exported getFacetedUniqueValues function.
                                                                                          Type
                                                                                          () =>
                                                                                          | FilterFn<TData>
                                                                                          | undefined
                                                                                          Description
                                                                                          Returns the filter function (either user-defined or automatic, depending on configuration) for the columnId specified.
                                                                                              Type
                                                                                              () => number
                                                                                              Description
                                                                                              Returns the index of the column filter in the table's state.columnFilters array. Returns -1 if not found.
                                                                                                  Type
                                                                                                  () => unknown
                                                                                                  Description
                                                                                                  Returns the current filter value for the column.
                                                                                                      Type
                                                                                                      () => boolean
                                                                                                      Description
                                                                                                      Returns whether the column is currently filtered.
                                                                                                          Type
                                                                                                          (
                                                                                                          updater: any,
                                                                                                          ) => void
                                                                                                          Description
                                                                                                          A function that sets the current filter value for the column. You can pass it a value or an updater function for immutability-safe operations on existing values.

                                                                                                              SortingColumn

                                                                                                              Properties and methods for controlling column sort behavior. Includes sort direction state, sort functions, and methods to toggle or clear sorting. See the Sorting guide for implementation details.

                                                                                                              PropType
                                                                                                              Removes this column from the table's sorting state
                                                                                                                  () => void
                                                                                                                  Returns a sort direction automatically inferred based on the columns values.
                                                                                                                      () =>
                                                                                                                      | 'asc'
                                                                                                                      | 'desc'
                                                                                                                      Returns a sorting function automatically inferred based on the columns values.
                                                                                                                          () => SortingFn<TData>
                                                                                                                          Returns whether this column can be multi-sorted.
                                                                                                                              () => boolean
                                                                                                                              Returns whether this column can be sorted.
                                                                                                                                  () => boolean
                                                                                                                                  Returns the first direction that should be used when sorting this column.

                                                                                                                                  Useful for tooltips and aria-labels.
                                                                                                                                      () =>
                                                                                                                                      | 'asc'
                                                                                                                                      | 'desc'
                                                                                                                                      Returns the current sort direction of this column.
                                                                                                                                          () =>
                                                                                                                                          | 'asc'
                                                                                                                                          | 'desc'
                                                                                                                                          | false
                                                                                                                                          Returns the next sorting order. Useful for tooltips and aria-labels.
                                                                                                                                              () =>
                                                                                                                                              | 'asc'
                                                                                                                                              | 'desc'
                                                                                                                                              | false
                                                                                                                                              Returns the index position of this column's sorting within the sorting state
                                                                                                                                                  () => number
                                                                                                                                                  Returns the resolved sorting function to be used for this column
                                                                                                                                                      () => SortingFn<TData>
                                                                                                                                                      Returns a function that can be used to toggle this column's sorting state. This is useful for attaching a click handler to the column header.
                                                                                                                                                          () =>
                                                                                                                                                          | ((event: unknown) => void)
                                                                                                                                                          | undefined
                                                                                                                                                          Toggles this columns sorting state. If desc is provided, it will force the sort direction to that value. If isMulti is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).
                                                                                                                                                              (
                                                                                                                                                              desc?: boolean,
                                                                                                                                                              isMulti?: boolean,
                                                                                                                                                              ) => void
                                                                                                                                                              Type
                                                                                                                                                              () => void
                                                                                                                                                              Description
                                                                                                                                                              Removes this column from the table's sorting state
                                                                                                                                                                  Type
                                                                                                                                                                  () =>
                                                                                                                                                                  | 'asc'
                                                                                                                                                                  | 'desc'
                                                                                                                                                                  Description
                                                                                                                                                                  Returns a sort direction automatically inferred based on the columns values.
                                                                                                                                                                      Type
                                                                                                                                                                      () => SortingFn<TData>
                                                                                                                                                                      Description
                                                                                                                                                                      Returns a sorting function automatically inferred based on the columns values.
                                                                                                                                                                          Type
                                                                                                                                                                          () => boolean
                                                                                                                                                                          Description
                                                                                                                                                                          Returns whether this column can be multi-sorted.
                                                                                                                                                                              Type
                                                                                                                                                                              () => boolean
                                                                                                                                                                              Description
                                                                                                                                                                              Returns whether this column can be sorted.
                                                                                                                                                                                  Type
                                                                                                                                                                                  () =>
                                                                                                                                                                                  | 'asc'
                                                                                                                                                                                  | 'desc'
                                                                                                                                                                                  Description
                                                                                                                                                                                  Returns the first direction that should be used when sorting this column.

                                                                                                                                                                                  Useful for tooltips and aria-labels.
                                                                                                                                                                                      Type
                                                                                                                                                                                      () =>
                                                                                                                                                                                      | 'asc'
                                                                                                                                                                                      | 'desc'
                                                                                                                                                                                      | false
                                                                                                                                                                                      Description
                                                                                                                                                                                      Returns the current sort direction of this column.
                                                                                                                                                                                          Type
                                                                                                                                                                                          () =>
                                                                                                                                                                                          | 'asc'
                                                                                                                                                                                          | 'desc'
                                                                                                                                                                                          | false
                                                                                                                                                                                          Description
                                                                                                                                                                                          Returns the next sorting order. Useful for tooltips and aria-labels.
                                                                                                                                                                                              Type
                                                                                                                                                                                              () => number
                                                                                                                                                                                              Description
                                                                                                                                                                                              Returns the index position of this column's sorting within the sorting state
                                                                                                                                                                                                  Type
                                                                                                                                                                                                  () => SortingFn<TData>
                                                                                                                                                                                                  Description
                                                                                                                                                                                                  Returns the resolved sorting function to be used for this column
                                                                                                                                                                                                      Type
                                                                                                                                                                                                      () =>
                                                                                                                                                                                                      | ((event: unknown) => void)
                                                                                                                                                                                                      | undefined
                                                                                                                                                                                                      Description
                                                                                                                                                                                                      Returns a function that can be used to toggle this column's sorting state. This is useful for attaching a click handler to the column header.
                                                                                                                                                                                                          Type
                                                                                                                                                                                                          (
                                                                                                                                                                                                          desc?: boolean,
                                                                                                                                                                                                          isMulti?: boolean,
                                                                                                                                                                                                          ) => void
                                                                                                                                                                                                          Description
                                                                                                                                                                                                          Toggles this columns sorting state. If desc is provided, it will force the sort direction to that value. If isMulti is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).

                                                                                                                                                                                                              GroupingColumn

                                                                                                                                                                                                              Properties and methods for grouping rows by column values and aggregating grouped data. Provides access to aggregation functions, grouped row state, and methods to toggle grouping. See the Grouping guide for implementation details.

                                                                                                                                                                                                              AggregationFn

                                                                                                                                                                                                              The AggregationFn interface is used on several of the GroupingColumn properties.

                                                                                                                                                                                                              export type AggregationFn<TData extends RowData> = (
                                                                                                                                                                                                                columnId: string,
                                                                                                                                                                                                                leafRows: Row<TData>[],
                                                                                                                                                                                                                childRows: Row<TData>[],
                                                                                                                                                                                                              ) => any
                                                                                                                                                                                                              PropType
                                                                                                                                                                                                              Returns the aggregation function for the column.
                                                                                                                                                                                                                  () =>
                                                                                                                                                                                                                  | AggregationFn<TData>
                                                                                                                                                                                                                  | undefined
                                                                                                                                                                                                                  Returns the automatically inferred aggregation function for the column.
                                                                                                                                                                                                                      () =>
                                                                                                                                                                                                                      | AggregationFn<TData>
                                                                                                                                                                                                                      | undefined
                                                                                                                                                                                                                      Returns whether the column can be grouped.
                                                                                                                                                                                                                          () => boolean
                                                                                                                                                                                                                          Returns the index of the column in the grouping state.
                                                                                                                                                                                                                              () => number
                                                                                                                                                                                                                              Returns whether the column is currently grouped.
                                                                                                                                                                                                                                  () => boolean
                                                                                                                                                                                                                                  Returns a function that toggles the grouping state of the column. This is useful for passing to the onClick prop of a button.
                                                                                                                                                                                                                                      () => () => void
                                                                                                                                                                                                                                      Toggles the grouping state of the column.
                                                                                                                                                                                                                                          () => void
                                                                                                                                                                                                                                          Type
                                                                                                                                                                                                                                          () =>
                                                                                                                                                                                                                                          | AggregationFn<TData>
                                                                                                                                                                                                                                          | undefined
                                                                                                                                                                                                                                          Description
                                                                                                                                                                                                                                          Returns the aggregation function for the column.
                                                                                                                                                                                                                                              Type
                                                                                                                                                                                                                                              () =>
                                                                                                                                                                                                                                              | AggregationFn<TData>
                                                                                                                                                                                                                                              | undefined
                                                                                                                                                                                                                                              Description
                                                                                                                                                                                                                                              Returns the automatically inferred aggregation function for the column.
                                                                                                                                                                                                                                                  Type
                                                                                                                                                                                                                                                  () => boolean
                                                                                                                                                                                                                                                  Description
                                                                                                                                                                                                                                                  Returns whether the column can be grouped.
                                                                                                                                                                                                                                                      Type
                                                                                                                                                                                                                                                      () => number
                                                                                                                                                                                                                                                      Description
                                                                                                                                                                                                                                                      Returns the index of the column in the grouping state.
                                                                                                                                                                                                                                                          Type
                                                                                                                                                                                                                                                          () => boolean
                                                                                                                                                                                                                                                          Description
                                                                                                                                                                                                                                                          Returns whether the column is currently grouped.
                                                                                                                                                                                                                                                              Type
                                                                                                                                                                                                                                                              () => () => void
                                                                                                                                                                                                                                                              Description
                                                                                                                                                                                                                                                              Returns a function that toggles the grouping state of the column. This is useful for passing to the onClick prop of a button.
                                                                                                                                                                                                                                                                  Type
                                                                                                                                                                                                                                                                  () => void
                                                                                                                                                                                                                                                                  Description
                                                                                                                                                                                                                                                                  Toggles the grouping state of the column.

                                                                                                                                                                                                                                                                      VisibilityColumn

                                                                                                                                                                                                                                                                      Properties and methods for controlling column visibility state. Provides methods to show, hide, or toggle column visibility. See the Column Visibility guide for implementation details.

                                                                                                                                                                                                                                                                      PropType
                                                                                                                                                                                                                                                                      Returns whether the column can be hidden.
                                                                                                                                                                                                                                                                        () => boolean
                                                                                                                                                                                                                                                                        Returns whether the column is visible.
                                                                                                                                                                                                                                                                          () => boolean
                                                                                                                                                                                                                                                                          Returns a function that can be used to toggle the column visibility. This function can be used to bind to an event handler to an element.
                                                                                                                                                                                                                                                                            () => (
                                                                                                                                                                                                                                                                            event: unknown,
                                                                                                                                                                                                                                                                            ) => void
                                                                                                                                                                                                                                                                            Toggles the visibility of the column.
                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                              value?: boolean,
                                                                                                                                                                                                                                                                              ) => void
                                                                                                                                                                                                                                                                              Type
                                                                                                                                                                                                                                                                              () => boolean
                                                                                                                                                                                                                                                                              Description
                                                                                                                                                                                                                                                                              Returns whether the column can be hidden.
                                                                                                                                                                                                                                                                                Type
                                                                                                                                                                                                                                                                                () => boolean
                                                                                                                                                                                                                                                                                Description
                                                                                                                                                                                                                                                                                Returns whether the column is visible.
                                                                                                                                                                                                                                                                                  Type
                                                                                                                                                                                                                                                                                  () => (
                                                                                                                                                                                                                                                                                  event: unknown,
                                                                                                                                                                                                                                                                                  ) => void
                                                                                                                                                                                                                                                                                  Description
                                                                                                                                                                                                                                                                                  Returns a function that can be used to toggle the column visibility. This function can be used to bind to an event handler to an element.
                                                                                                                                                                                                                                                                                    Type
                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                    value?: boolean,
                                                                                                                                                                                                                                                                                    ) => void
                                                                                                                                                                                                                                                                                    Description
                                                                                                                                                                                                                                                                                    Toggles the visibility of the column.

                                                                                                                                                                                                                                                                                      ColumnPinningColumn

                                                                                                                                                                                                                                                                                      Properties and methods for pinning columns to the left or right side of the table. Includes pinning state and methods to pin or unpin columns. See the Column Pinning guide for implementation details.

                                                                                                                                                                                                                                                                                      PropType
                                                                                                                                                                                                                                                                                      Returns whether the column can be pinned.
                                                                                                                                                                                                                                                                                        () => boolean
                                                                                                                                                                                                                                                                                        Returns the pinned position of the column. ('left', 'right' or false)
                                                                                                                                                                                                                                                                                          () =>
                                                                                                                                                                                                                                                                                          | 'left'
                                                                                                                                                                                                                                                                                          | 'right'
                                                                                                                                                                                                                                                                                          | false
                                                                                                                                                                                                                                                                                          Returns whether the column is pinned to the left.
                                                                                                                                                                                                                                                                                            () => boolean
                                                                                                                                                                                                                                                                                            Returns whether the column is pinned to the right.
                                                                                                                                                                                                                                                                                              () => boolean
                                                                                                                                                                                                                                                                                              Returns the numeric pinned index of the column within a pinned column group.
                                                                                                                                                                                                                                                                                                () => number
                                                                                                                                                                                                                                                                                                Pins a column to the 'left' or 'right', or unpins the column to the center if false is passed.
                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                  position:
                                                                                                                                                                                                                                                                                                  | 'left'
                                                                                                                                                                                                                                                                                                  | 'right'
                                                                                                                                                                                                                                                                                                  | false,
                                                                                                                                                                                                                                                                                                  ) => void
                                                                                                                                                                                                                                                                                                  Type
                                                                                                                                                                                                                                                                                                  () => boolean
                                                                                                                                                                                                                                                                                                  Description
                                                                                                                                                                                                                                                                                                  Returns whether the column can be pinned.
                                                                                                                                                                                                                                                                                                    Type
                                                                                                                                                                                                                                                                                                    () =>
                                                                                                                                                                                                                                                                                                    | 'left'
                                                                                                                                                                                                                                                                                                    | 'right'
                                                                                                                                                                                                                                                                                                    | false
                                                                                                                                                                                                                                                                                                    Description
                                                                                                                                                                                                                                                                                                    Returns the pinned position of the column. ('left', 'right' or false)
                                                                                                                                                                                                                                                                                                      Type
                                                                                                                                                                                                                                                                                                      () => boolean
                                                                                                                                                                                                                                                                                                      Description
                                                                                                                                                                                                                                                                                                      Returns whether the column is pinned to the left.
                                                                                                                                                                                                                                                                                                        Type
                                                                                                                                                                                                                                                                                                        () => boolean
                                                                                                                                                                                                                                                                                                        Description
                                                                                                                                                                                                                                                                                                        Returns whether the column is pinned to the right.
                                                                                                                                                                                                                                                                                                          Type
                                                                                                                                                                                                                                                                                                          () => number
                                                                                                                                                                                                                                                                                                          Description
                                                                                                                                                                                                                                                                                                          Returns the numeric pinned index of the column within a pinned column group.
                                                                                                                                                                                                                                                                                                            Type
                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                            position:
                                                                                                                                                                                                                                                                                                            | 'left'
                                                                                                                                                                                                                                                                                                            | 'right'
                                                                                                                                                                                                                                                                                                            | false,
                                                                                                                                                                                                                                                                                                            ) => void
                                                                                                                                                                                                                                                                                                            Description
                                                                                                                                                                                                                                                                                                            Pins a column to the 'left' or 'right', or unpins the column to the center if false is passed.

                                                                                                                                                                                                                                                                                                              ColumnSizingColumn

                                                                                                                                                                                                                                                                                                              Properties and methods for managing column width and resizing behavior. Includes current size, min/max constraints, and methods to set or reset column dimensions. See the Column Sizing guide for implementation details.

                                                                                                                                                                                                                                                                                                              PropType
                                                                                                                                                                                                                                                                                                              Returns true if the column can be resized.
                                                                                                                                                                                                                                                                                                                () => boolean
                                                                                                                                                                                                                                                                                                                Returns true if the column is currently being resized.
                                                                                                                                                                                                                                                                                                                  () => boolean
                                                                                                                                                                                                                                                                                                                  Returns the current size of the column.
                                                                                                                                                                                                                                                                                                                    () => number
                                                                                                                                                                                                                                                                                                                    Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all preceding headers.
                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      position?:
                                                                                                                                                                                                                                                                                                                      | 'left'
                                                                                                                                                                                                                                                                                                                      | 'right'
                                                                                                                                                                                                                                                                                                                      | false,
                                                                                                                                                                                                                                                                                                                      ) => number
                                                                                                                                                                                                                                                                                                                      Resets the column to its initial size.
                                                                                                                                                                                                                                                                                                                        () => void
                                                                                                                                                                                                                                                                                                                        Type
                                                                                                                                                                                                                                                                                                                        () => boolean
                                                                                                                                                                                                                                                                                                                        Description
                                                                                                                                                                                                                                                                                                                        Returns true if the column can be resized.
                                                                                                                                                                                                                                                                                                                          Type
                                                                                                                                                                                                                                                                                                                          () => boolean
                                                                                                                                                                                                                                                                                                                          Description
                                                                                                                                                                                                                                                                                                                          Returns true if the column is currently being resized.
                                                                                                                                                                                                                                                                                                                            Type
                                                                                                                                                                                                                                                                                                                            () => number
                                                                                                                                                                                                                                                                                                                            Description
                                                                                                                                                                                                                                                                                                                            Returns the current size of the column.
                                                                                                                                                                                                                                                                                                                              Type
                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                              position?:
                                                                                                                                                                                                                                                                                                                              | 'left'
                                                                                                                                                                                                                                                                                                                              | 'right'
                                                                                                                                                                                                                                                                                                                              | false,
                                                                                                                                                                                                                                                                                                                              ) => number
                                                                                                                                                                                                                                                                                                                              Description
                                                                                                                                                                                                                                                                                                                              Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all preceding headers.
                                                                                                                                                                                                                                                                                                                                Type
                                                                                                                                                                                                                                                                                                                                () => void
                                                                                                                                                                                                                                                                                                                                Description
                                                                                                                                                                                                                                                                                                                                Resets the column to its initial size.
                                                                                                                                                                                                                                                                                                                                  Updated by Ryan Bower