@uselets/ui 1.18.1 → 1.18.3

package/dist/data-table-DXNWHN9R.d.ts

@@ -0,0 +1,4184 @@
+import { n as __name } from "./rolldown-runtime-Bdj-bS2b.js";
+import { t as Button } from "./button-BNGy28pv.js";
+import { g as TableProps } from "./table-qIAtG7Y5.js";
+import * as React from "react";
+import { Column, ColumnDef, ReactTable, RowData, RowData as RowData$1 } from "@tanstack/react-table";
+//#region ../../node_modules/@tanstack/table-core/dist/types/type-utils.d.ts
+//#region src/types/type-utils.d.ts
+type Updater<T> = T | ((old: T) => T);
+type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+type RowData$2 = Record<string, any> | Array<any>;
+type CellData = unknown;
+/**
+ * Normalizes a row's value before a filter or sort comparator sees it.
+ *
+ * Attach as `resolveDataValue` on filter/sort functions built with
+ * `constructFilterFn`/`constructSortFn` (e.g. to lowercase or strip diacritics).
+ */
+type TransformDataValueFn = (dataValue: any) => any;
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends ((x: infer R) => any) ? R : never;
+type NoInfer$1<T> = [T][T extends any ? 0 : never];
+type Getter<TValue> = <TTValue = TValue>() => NoInfer$1<TTValue>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/columns/coreColumnsFeature.d.ts
+//#region src/core/columns/coreColumnsFeature.d.ts
+/**
+ * Core feature that builds the column tree and exposes table/column APIs.
+ */
+declare const coreColumnsFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/headers/coreHeadersFeature.d.ts
+//#region src/core/headers/coreHeadersFeature.d.ts
+/**
+ * Core feature that builds header groups and exposes header context APIs.
+ */
+declare const coreHeadersFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/row-models/coreRowModelsFeature.d.ts
+//#region src/core/row-models/coreRowModelsFeature.d.ts
+/**
+ * Core feature that wires table row-model accessors and row-model caches.
+ */
+declare const coreRowModelsFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/rows/coreRowsFeature.d.ts
+//#region src/core/rows/coreRowsFeature.d.ts
+/**
+ * Core feature that creates row APIs for values, cells, and tree traversal.
+ */
+declare const coreRowsFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/table/coreTablesFeature.d.ts
+//#region src/core/table/coreTablesFeature.d.ts
+/**
+ * Core feature that adds base table instance APIs such as reset and setOptions.
+ */
+declare const coreTablesFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/store/dist/types.d.ts
+interface InteropSubscribable<T> {
+  subscribe: (observer: Observer<T>) => Subscription;
+}
+type Observer<T> = {
+  next?: (value: T) => void;
+  error?: (err: unknown) => void;
+  complete?: () => void;
+};
+interface Subscription {
+  unsubscribe: () => void;
+}
+interface Subscribable<T> extends InteropSubscribable<T> {
+  subscribe: ((observer: Observer<T>) => Subscription) & ((next: (value: T) => void, error?: (error: any) => void, complete?: () => void) => Subscription);
+}
+interface Readable<T> extends Subscribable<T> {
+  get: () => T;
+}
+interface BaseAtom<T> extends Subscribable<T>, Readable<T> {}
+interface Atom<T> extends BaseAtom<T> {
+  /** Sets the value of the atom using a function. */
+  set: ((fn: (prevVal: T) => T) => void) & ((value: T) => void);
+}
+interface AtomOptions<T> {
+  compare?: (prev: T, next: T) => boolean;
+}
+/**
+ * An atom that is read-only and cannot be set.
+ *
+ * @example
+ *
+ * ```ts
+ * const atom = createAtom(() => 42);
+ * // @ts-expect-error - Cannot set a readonly atom
+ * atom.set(43);
+ * ```
+ */
+interface ReadonlyAtom<T> extends BaseAtom<T> {}
+//#endregion
+//#region ../../node_modules/@tanstack/store/dist/store.d.ts
+//#region src/store.d.ts
+type StoreAction = (...args: Array<any>) => any;
+type StoreActionMap = Record<string, StoreAction>;
+type StoreActionsFactory<T, TActions extends StoreActionMap> = (store: {
+  setState: Store<T>['setState'];
+  get: Store<T>['get'];
+}) => TActions;
+type NonFunction<T> = T extends ((...args: Array<any>) => any) ? never : T;
+declare class Store<T, TActions extends StoreActionMap = never> {
+  private atom;
+  readonly actions: TActions;
+  constructor(getValue: (prev?: NoInfer<T>) => T);
+  constructor(initialValue: T);
+  constructor(initialValue: NonFunction<T>, actionsFactory: StoreActionsFactory<T, TActions>);
+  setState(updater: (prev: T) => T): void;
+  get state(): T;
+  get(): T;
+  subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
+}
+declare class ReadonlyStore<T> implements Omit<Store<T>, 'setState' | 'actions'> {
+  private atom;
+  constructor(getValue: (prev?: NoInfer<T>) => T);
+  constructor(initialValue: T);
+  get state(): T;
+  get(): T;
+  subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/reactivity/coreReactivityFeature.types.d.ts
+//#region src/core/reactivity/coreReactivityFeature.types.d.ts
+interface TableAtomOptions<T> extends AtomOptions<T> {
+  /**
+   * A debug name for the atom, useful for debugging.
+   */
+  debugName: string;
+}
+/**
+ * Framework reactivity bindings used by table-core.
+ *
+ * Adapters (React, Solid, Vue, etc.) provide concrete implementations so
+ * core features can create derived/writable atoms and integrate with their
+ * scheduling primitives.
+ */
+interface TableReactivityBindings {
+  createOptionsStore: boolean;
+  wrapExternalAtoms: boolean;
+  /**
+   * Invalidates readonly atoms whose compute reads non-reactive inputs (plain
+   * options). Render-phase adapters call this after publishing captured
+   * controlled state from a host commit, including when no base atom changed,
+   * so controlled ownership changes still reach subscribers.
+   */
+  commit?: () => void;
+  addSubscription: (subscription: Subscription) => void;
+  /**
+   * Creates a writable atom with an initial value.
+   */
+  createWritableAtom: <T>(initialValue: T, options?: TableAtomOptions<T>) => Atom<T>;
+  /**
+   * Creates a readonly/derived atom from a compute function.
+   */
+  createReadonlyAtom: <T>(fn: () => T, options?: TableAtomOptions<T>) => ReadonlyAtom<T>;
+  /**
+   * Evaluates a function without tracking reactive dependencies.
+   */
+  untrack: <T>(fn: () => T) => T;
+  /**
+   * Batches reactive updates to avoid intermediate recomputation.
+   */
+  batch: (fn: () => void) => void;
+  /**
+   * Schedules a function to run. This is used to defer updates after the current call stack (render, etc.) has finished
+   */
+  schedule: (fn: () => void) => void;
+  /**
+   * Unmounts the table, performing any necessary cleanup. This is called when the table is destroyed or unmounted in the framework adapter.
+   */
+  unmount?: () => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/coreFeatures.d.ts
+//#region src/core/coreFeatures.d.ts
+interface CoreFeatures {
+  coreReactivityFeature?: TableReactivityBindings;
+  coreCellsFeature: typeof coreCellsFeature;
+  coreColumnsFeature: typeof coreColumnsFeature;
+  coreHeadersFeature: typeof coreHeadersFeature;
+  coreRowModelsFeature: typeof coreRowModelsFeature;
+  coreRowsFeature: typeof coreRowsFeature;
+  coreTablesFeature: typeof coreTablesFeature;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-sorting/sortFns.d.ts
+/**
+ * The built-in sorting function registry.
+ *
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
+ */
+declare const sortFns: {
+  alphanumeric: CreatedSortFn<any, any>;
+  alphanumericCaseSensitive: CreatedSortFn<any, any>;
+  basic: CreatedSortFn<any, any>;
+  datetime: CreatedSortFn<any, any>;
+  text: CreatedSortFn<any, any>;
+  textCaseSensitive: CreatedSortFn<any, any>;
+};
+type BuiltInSortFn = keyof typeof sortFns;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-sizing/columnSizingFeature.types.d.ts
+//#region src/features/column-sizing/columnSizingFeature.types.d.ts
+interface TableState_ColumnSizing {
+  columnSizing: ColumnSizingState;
+}
+type ColumnSizingState = Record<string, number>;
+interface ColumnOffsets {
+  /**
+   * Offset from the start edge of the region to each column's start edge,
+   * keyed by column id.
+   */
+  starts: Record<string, number>;
+  /**
+   * Offset from the end edge of the region to each column's end edge, keyed by
+   * column id.
+   */
+  afters: Record<string, number>;
+}
+interface ColumnOffsetsByPosition {
+  /**
+   * Offsets across all visible leaf columns, ignoring pinning regions.
+   */
+  all: ColumnOffsets;
+  /**
+   * Offsets within the center (unpinned) region.
+   */
+  center: ColumnOffsets;
+  /**
+   * Offsets within the logical start pinned region.
+   *
+   * In LTR languages/layouts, start usually corresponds to left. In RTL
+   * languages/layouts, start usually corresponds to right.
+   */
+  start: ColumnOffsets;
+  /**
+   * Offsets within the logical end pinned region.
+   *
+   * In LTR languages/layouts, end usually corresponds to right. In RTL
+   * languages/layouts, end usually corresponds to left.
+   */
+  end: ColumnOffsets;
+}
+interface TableOptions_ColumnSizing {
+  /**
+   * Called with an updater when committed column sizing state changes. Pair
+   * this with `state.columnSizing` when using external state; external atoms
+   * can own the slice without this callback.
+   */
+  onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+}
+interface Table_ColumnSizing {
+  /**
+   * Sums the current sizes of visible center-region leaf columns.
+   */
+  getCenterTotalSize: () => number;
+  /**
+   * Returns memoized column offset maps (start and after offsets keyed by
+   * column id) for each pinning region plus the full visible leaf column list.
+   *
+   * Backs `column.getStart()` and `column.getAfter()` with O(1) lookups.
+   */
+  getColumnOffsets: () => ColumnOffsetsByPosition;
+  /**
+   * Sums the current sizes of visible logical start-pinned leaf columns.
+   */
+  getStartTotalSize: () => number;
+  /**
+   * Sums the current sizes of visible logical end-pinned leaf columns.
+   */
+  getEndTotalSize: () => number;
+  /**
+   * Sums the current sizes of all visible leaf columns.
+   */
+  getTotalSize: () => number;
+  /**
+   * Resets column sizing to `initialState.columnSizing`. Pass `true` to reset
+   * to the feature default of `{}`.
+   */
+  resetColumnSizing: (defaultState?: boolean) => void;
+  /**
+   * Updates committed column sizing state with a next map or updater function.
+   */
+  setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
+}
+interface ColumnDef_ColumnSizing {
+  /**
+   * Upper bound used when resolving this column's size.
+   */
+  maxSize?: number;
+  /**
+   * Lower bound used when resolving this column's size.
+   */
+  minSize?: number;
+  /**
+   * Initial size used before column sizing state overrides it.
+   */
+  size?: number;
+}
+interface Column_ColumnSizing {
+  /**
+   * Measures the offset from this column's end edge to the end of its region.
+   *
+   * Pass a pinned region to measure within that logical region. The value is
+   * the sum of visible leaf column sizes after this column.
+   */
+  getAfter: (position?: ColumnPinningPosition | 'center') => number;
+  /**
+   * Resolves the column's current size after state and min/max constraints.
+   */
+  getSize: () => number;
+  /**
+   * Measures the offset from the start of this column's region to its start
+   * edge.
+   *
+   * Pass a pinned region to measure within that logical region. The value is
+   * the sum of visible leaf column sizes before this column.
+   */
+  getStart: (position?: ColumnPinningPosition | 'center') => number;
+  /**
+   * Resets the column to its initial size.
+   */
+  resetSize: () => void;
+}
+interface Header_ColumnSizing {
+  /**
+   * Computes this header's rendered size from its leaf columns.
+   */
+  getSize: () => 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.
+   */
+  getStart: (position?: ColumnPinningPosition) => number;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-resizing/columnResizingFeature.types.d.ts
+//#region src/features/column-resizing/columnResizingFeature.types.d.ts
+interface TableState_ColumnResizing {
+  columnResizing: columnResizingState;
+}
+interface columnResizingState {
+  columnSizingStart: Array<[string, number]>;
+  deltaOffset: null | number;
+  deltaPercentage: null | number;
+  isResizingColumn: false | string;
+  startOffset: null | number;
+  startSize: null | number;
+}
+type ColumnResizeMode = 'onChange' | 'onEnd';
+type ColumnResizeDirection = 'ltr' | 'rtl';
+interface TableOptions_ColumnResizing {
+  /**
+   * Determines when committed `columnSizing` values are updated. `onChange`
+   * commits sizes while the resize handle is dragged; `onEnd` commits when the
+   * resize interaction finishes.
+   */
+  columnResizeMode?: ColumnResizeMode;
+  /**
+   * Enables or disables column resizing for the whole table.
+   */
+  enableColumnResizing?: boolean;
+  /**
+   * Sets the resize direction used to calculate drag offsets. Defaults to `ltr`.
+   */
+  columnResizeDirection?: ColumnResizeDirection;
+  /**
+   * Called with an updater when the transient `columnResizing` state changes.
+   * Pair this with `state.columnResizing` when using external state; external
+   * atoms can own the slice without this callback.
+   */
+  onColumnResizingChange?: OnChangeFn<columnResizingState>;
+}
+interface Table_ColumnResizing {
+  /**
+   * Resets `columnResizing` to `initialState.columnResizing`.
+   *
+   * Pass `true` to ignore initial state and reset to the no-drag default state.
+   */
+  resetHeaderSizeInfo: (defaultState?: boolean) => void;
+  /**
+   * Updates transient resize interaction state with a next state or updater function.
+   */
+  setColumnResizing: (updater: Updater<columnResizingState>) => void;
+}
+interface ColumnDef_ColumnResizing {
+  /**
+   * Enables or disables column resizing for the column.
+   */
+  enableResizing?: boolean;
+}
+interface Column_ColumnResizing {
+  /**
+   * Checks whether this column can start a resize interaction.
+   */
+  getCanResize: () => boolean;
+  /**
+   * Checks whether this column is the active resize target.
+   */
+  getIsResizing: () => boolean;
+}
+interface Header_ColumnResizing {
+  /**
+   * Creates the `onMouseDown`/`onTouchStart` handler for a resize handle.
+   *
+   * Dragging and release listeners are installed and cleaned up automatically.
+   */
+  getResizeHandler: (context?: Document) => (event: unknown) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/Header.d.ts
+//#region src/types/Header.d.ts
+interface Header_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> extends Header_Header<TFeatures, TData, TValue> {}
+interface Header_FeatureMap {
+  columnSizingFeature: Header_ColumnSizing;
+  columnResizingFeature: Header_ColumnResizing;
+}
+type Header<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = Header_Core<TFeatures, TData, TValue> & ExtractFeatureMapTypes<TFeatures, Header_FeatureMap>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-expanding/rowExpandingFeature.types.d.ts
+type ExpandedState = true | Record<string, boolean>;
+interface TableState_RowExpanding {
+  expanded: ExpandedState;
+}
+interface Row_RowExpanding {
+  /**
+   * Checks whether this row can be expanded.
+   */
+  getCanExpand: () => boolean;
+  /**
+   * Checks whether every ancestor of this row is expanded.
+   */
+  getIsAllParentsExpanded: () => boolean;
+  /**
+   * Checks whether this row is currently expanded.
+   */
+  getIsExpanded: () => boolean;
+  /**
+   * Creates a handler that toggles this row's expanded state.
+   */
+  getToggleExpandedHandler: () => () => void;
+  /**
+   * Toggles the expanded state (or sets it if `expanded` is provided) for the row.
+   */
+  toggleExpanded: (expanded?: boolean) => void;
+}
+interface TableOptions_RowExpanding<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Enables automatic expanded-state resets when page-altering table state changes.
+   */
+  autoResetExpanded?: boolean;
+  /**
+   * Allows rows with subRows to be expanded.
+   */
+  enableExpanding?: boolean;
+  /**
+   * If provided, allows you to override the default behavior of determining whether a row is currently expanded.
+   */
+  getIsRowExpanded?: (row: Row<TFeatures, TData>) => boolean;
+  /**
+   * If provided, allows you to override the default behavior of determining whether a row can be expanded.
+   */
+  getRowCanExpand?: (row: Row<TFeatures, TData>) => boolean;
+  /**
+   * Enables manual row expansion. If this is set to `true`, `getExpandedRowModel` will not be used to expand rows and you would be expected to perform the expansion in your own data model. This is useful if you are doing server-side expansion.
+   */
+  manualExpanding?: boolean;
+  /**
+   * Called with an updater when expanded state changes. Pair this with
+   * `state.expanded` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onExpandedChange?: OnChangeFn<ExpandedState>;
+  /**
+   * If `true` expanded rows will be paginated along with the rest of the table (which means expanded rows may span multiple pages). If `false` expanded rows will not be considered for pagination (which means expanded rows will always render on their parent's page). This also means more rows will be rendered than the set page size.
+   */
+  paginateExpandedRows?: boolean;
+}
+interface Table_RowExpanding<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  autoResetExpanded: () => void;
+  /**
+   * Checks whether at least one row can be expanded.
+   */
+  getCanSomeRowsExpand: () => boolean;
+  /**
+   * Computes the deepest expanded row id depth.
+   */
+  getExpandedDepth: () => number;
+  /**
+   * Checks whether all rows in the current row model are expanded.
+   */
+  getIsAllRowsExpanded: () => boolean;
+  /**
+   * Checks whether any row is currently expanded.
+   */
+  getIsSomeRowsExpanded: () => boolean;
+  /**
+   * Creates a handler that toggles all rows expanded.
+   */
+  getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+  /**
+   * Resets `expanded` to `initialState.expanded`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
+   */
+  resetExpanded: (defaultState?: boolean) => void;
+  /**
+   * Updates expanded state with `true`, a row-id map, or an updater function.
+   */
+  setExpanded: (updater: Updater<ExpandedState>) => void;
+  /**
+   * Toggles the expanded state for all rows.
+   */
+  toggleAllRowsExpanded: (expanded?: boolean) => void;
+}
+interface Table_RowModels_Expanded<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Resolves the row model after expanded rows have been flattened into view.
+   */
+  getExpandedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Reads the row model immediately before expansion.
+   */
+  getPreExpandedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Expanded<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  expandedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-filtering/filterFns.d.ts
+/**
+ * The built-in filter function registry.
+ *
+ * Registering this full object opts out of tree-shaking: every built-in
+ * filter function ends up in your bundle. Prefer importing the `filterFn_*`
+ * functions you actually use and registering just those in the `filterFns`
+ * slot, or passing them directly to the `filterFn` column option.
+ *
+ * @deprecated Import individual `filterFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `filterFn: 'auto'`) only finds functions you
+ * register yourself.
+ */
+declare const filterFns: {
+  arrIncludes: CreatedFilterFn<any, any>;
+  arrIncludesAll: CreatedFilterFn<any, any>;
+  arrHas: CreatedFilterFn<any, any>;
+  arrIncludesSome: CreatedFilterFn<any, any>;
+  between: CreatedFilterFn<any, any>;
+  betweenInclusive: CreatedFilterFn<any, any>;
+  empty: CreatedFilterFn<any, any>;
+  endsWith: CreatedFilterFn<any, any>;
+  equals: CreatedFilterFn<any, any>;
+  equalsString: CreatedFilterFn<any, any>;
+  equalsStringSensitive: CreatedFilterFn<any, any>;
+  inDateRange: CreatedFilterFn<any, any>;
+  inNumberRange: CreatedFilterFn<any, any>;
+  includesString: CreatedFilterFn<any, any>;
+  includesStringSensitive: CreatedFilterFn<any, any>;
+  notEmpty: CreatedFilterFn<any, any>;
+  startsWith: CreatedFilterFn<any, any>;
+  weakEquals: CreatedFilterFn<any, any>;
+};
+type BuiltInFilterFn = keyof typeof filterFns;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-filtering/columnFilteringFeature.types.d.ts
+//#region src/features/column-filtering/columnFilteringFeature.types.d.ts
+interface FilterMeta {}
+/**
+ * Resolves the type of the filter meta attached to rows for a feature set.
+ *
+ * When the features object declares a `filterMeta` type-only slot
+ * (`tableFeatures({ ..., filterMeta: {} as MyFilterMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `FilterMeta`
+ * interface.
+ */
+type ExtractFilterMeta<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? FilterMeta : TFeatures extends {
+  filterMeta: infer TFilterMeta extends object;
+} ? TFilterMeta : FilterMeta;
+interface FilterFns {}
+interface TableState_ColumnFiltering {
+  columnFilters: ColumnFiltersState;
+}
+type ColumnFiltersState = Array<ColumnFilter>;
+interface ColumnFilter {
+  id: string;
+  value: unknown;
+}
+interface RowModelFns_ColumnFiltering<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  filterFns: Record<string, FilterFn<TFeatures, TData>>;
+}
+interface FilterFn<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  (row: Row<TFeatures, TData>, columnId: string, filterValue: any, addMeta?: (meta: ExtractFilterMeta<TFeatures>) => void): boolean;
+  /**
+   * Removes the filter from `state.columnFilters` when the filter value fails
+   * this test (e.g. empty strings for text filters).
+   *
+   * When provided, this test is authoritative: values it keeps stay in filter
+   * state even when they are empty strings, which the default heuristic would
+   * otherwise remove. An `undefined` filter value always clears the filter
+   * regardless.
+   */
+  autoRemove?: ColumnFilterAutoRemoveTestFn<TFeatures, TData>;
+  /**
+   * Normalizes the filter value before filtering runs.
+   *
+   * The table applies this once per filter (not per row) and passes the
+   * resolved value to the filter function as `filterValue`.
+   */
+  resolveFilterValue?: TransformFilterValueFn<TFeatures, TData>;
+  /**
+   * Normalizes each row's value before it is compared against the filter
+   * value. Only honored by filter functions built with `constructFilterFn`
+   * (including all built-in filter functions).
+   */
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The definition object accepted by `constructFilterFn`.
+ *
+ * `filter` is a value-level comparator: it receives the row's (resolved) data
+ * value and the (resolved) filter value instead of the whole row, so
+ * normalization concerns stay in `resolveDataValue`/`resolveFilterValue`.
+ */
+interface FilterFnDef<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  filter: (dataValue: any, filterValue: any, row: Row<TFeatures, TData>, columnId: string, addMeta?: (meta: ExtractFilterMeta<TFeatures>) => void) => boolean;
+  autoRemove?: (filterValue: any) => boolean;
+  resolveFilterValue?: (filterValue: any) => any;
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The shape returned by `constructFilterFn`: a `FilterFn` with its definition
+ * attached, so variants can be built by spreading it into another
+ * `constructFilterFn` call.
+ *
+ * The call signature is generic so a created filter function can be used with
+ * any table's rows, regardless of the feature set it was defined against.
+ */
+interface CreatedFilterFn<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends FilterFnDef<TFeatures, TData> {
+  <TRowFeatures extends TableFeatures, TRowData extends RowData$2>(row: Row<TRowFeatures, TRowData>, columnId: string, filterValue: any, addMeta?: (meta: ExtractFilterMeta<TRowFeatures>) => void): boolean;
+}
+type TransformFilterValueFn<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = (value: any, column?: Column$2<TFeatures, TData, TValue>) => TValue;
+type ColumnFilterAutoRemoveTestFn<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = (value: any, column?: Column$2<TFeatures, TData, TValue>) => boolean;
+/**
+ * Resolves the valid string names for `columnDef.filterFn` and
+ * `options.globalFilterFn` for a feature set.
+ *
+ * When the features object declares a `filterFns` registry
+ * (`tableFeatures({ ..., filterFns })`), its keys are the only valid names; a
+ * name is only assignable if a filter function is actually registered for it.
+ * Otherwise this falls back to the global declaration-merged `FilterFns`
+ * interface.
+ */
+type ExtractFilterFnKeys<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? keyof FilterFns | BuiltInFilterFn : TFeatures extends {
+  filterFns: infer TFilterFns extends object;
+} ? Extract<keyof TFilterFns, string> : keyof FilterFns;
+type FilterFnOption<TFeatures extends TableFeatures, TData extends RowData$2> = 'auto' | ExtractFilterFnKeys<TFeatures> | FilterFn<TFeatures, TData>;
+interface ColumnDef_ColumnFiltering<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Enables this column to participate in column-specific filtering.
+   *
+   * Defaults to `true`; table-level `enableColumnFilters` and `enableFilters`
+   * must also allow filtering.
+   */
+  enableColumnFilter?: boolean;
+  /**
+   * The filter function to use with this column. Can be the name of a built-in filter function or a custom filter function.
+   */
+  filterFn?: FilterFnOption<TFeatures, TData>;
+}
+interface Column_ColumnFiltering<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Returns an automatically calculated filter function for the column based off of the columns first known value.
+   */
+  getAutoFilterFn: () => FilterFn<TFeatures, TData>;
+  /**
+   * Checks whether this accessor column can currently be column-filtered.
+   */
+  getCanFilter: () => boolean;
+  /**
+   * Returns the filter function (either user-defined or automatic, depending on configuration) for the columnId specified.
+   */
+  getFilterFn: () => FilterFn<TFeatures, TData>;
+  /**
+   * Returns the index (including `-1`) of the column filter in the table's `state.columnFilters` array.
+   */
+  getFilterIndex: () => number;
+  /**
+   * Reads this column's current value from `state.columnFilters`.
+   */
+  getFilterValue: () => unknown;
+  /**
+   * Checks whether this column has an active entry in `state.columnFilters`.
+   */
+  getIsFiltered: () => boolean;
+  /**
+   * Adds, updates, or removes this column's filter value.
+   *
+   * Updater functions receive the previous filter value. Values that satisfy
+   * the filter function's `autoRemove` rule are removed from filter state.
+   */
+  setFilterValue: (updater: Updater<any>) => void;
+}
+interface Row_ColumnFiltering<in out TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  /**
+   * The column filters map for the row. This object tracks whether a row is passing/failing specific filters by their column ID.
+   */
+  columnFilters: Record<string, boolean>;
+  /**
+   * The column filters meta map for the row. This object tracks any filter meta for a row as optionally provided during the filtering process.
+   */
+  columnFiltersMeta: Record<string, ExtractFilterMeta<TFeatures>>;
+}
+interface TableOptions_ColumnFiltering<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  /**
+   * Enables column-specific filtering for all columns that also allow it.
+   */
+  enableColumnFilters?: boolean;
+  /**
+   * Enables all filtering features for the table.
+   *
+   * Set this to `false` to disable both column filtering and global filtering.
+   */
+  enableFilters?: boolean;
+  /**
+   * By default, filtering is done from parent rows down (so if a parent row is filtered out, all of its children will be filtered out as well). Setting this option to `true` will cause filtering to be done from leaf rows up (which means parent rows will be included so long as one of their child or grand-child rows is also included).
+   */
+  filterFromLeafRows?: boolean;
+  /**
+   * Disables the `getFilteredRowModel` from being used to filter data. This may be useful if your table needs to dynamically support both client-side and server-side filtering.
+   */
+  manualFiltering?: boolean;
+  /**
+   * By default, filtering is done for all rows (max depth of 100), no matter if they are root level parent rows or the child leaf rows of a parent row. Setting this option to `0` will cause filtering to only be applied to the root level parent rows, with all sub-rows remaining unfiltered. Similarly, setting this option to `1` will cause filtering to only be applied to child leaf rows 1 level deep, and so on.
+   * This is useful for situations where you want a row's entire child hierarchy to be visible regardless of the applied filter.
+   */
+  maxLeafRowFilterDepth?: number;
+  /**
+   * Called with an updater when column filter state changes. Pair this with
+   * `state.columnFilters` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+}
+interface Table_ColumnFiltering {
+  /**
+   * Resets `columnFilters` to `initialState.columnFilters`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetColumnFilters: (defaultState?: boolean) => void;
+  /**
+   * Updates column filter state with a next array or updater function.
+   */
+  setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+}
+interface Table_RowModels_Filtered<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Resolves the row model after column and global filters have been applied.
+   */
+  getFilteredRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Reads the row model immediately before filtering.
+   */
+  getPreFilteredRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Filtered<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  filteredRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-pagination/rowPaginationFeature.types.d.ts
+//#region src/features/row-pagination/rowPaginationFeature.types.d.ts
+interface PaginationState {
+  pageIndex: number;
+  /**
+   * The number of rows per page. Set to `Infinity` to place all rows on a
+   * single page.
+   */
+  pageSize: number;
+}
+interface TableState_RowPagination {
+  pagination: PaginationState;
+}
+interface TableOptions_RowPagination {
+  /**
+   * If set to `true`, pagination will be reset to the first page when page-altering state changes e.g. `data` is updated, filters change, grouping changes, etc.
+   */
+  autoResetPageIndex?: boolean;
+  /**
+   * Enables manual pagination. If this option is set to `true`, the table will not automatically paginate rows using `getPaginatedRowModel()` and instead will expect you to manually paginate the rows before passing them to the table. This is useful if you are doing server-side pagination and aggregation.
+   */
+  manualPagination?: boolean;
+  /**
+   * Called with an updater when pagination state changes. Pair this with
+   * `state.pagination` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onPaginationChange?: OnChangeFn<PaginationState>;
+  /**
+   * When manually controlling pagination, you can supply a total `pageCount` value to the table if you know it (Or supply a `rowCount` and `pageCount` will be calculated). If you do not know how many pages there are, you can set this to `-1`.
+   */
+  pageCount?: number;
+  /**
+   * When manually controlling pagination, you can supply a total `rowCount` value to the table if you know it. The `pageCount` can be calculated from this value and the `pageSize`.
+   */
+  rowCount?: number;
+}
+interface Table_RowPagination<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  _autoResetPageIndex: () => void;
+  /**
+   * Checks whether the current page index can move forward.
+   */
+  getCanNextPage: () => boolean;
+  /**
+   * Checks whether a known, finite last page exists after the current page.
+   */
+  getCanLastPage: () => boolean;
+  /**
+   * Checks whether the current page index can move backward.
+   */
+  getCanPreviousPage: () => boolean;
+  /**
+   * Resolves the current page count from `options.pageCount` or row count and
+   * page size.
+   */
+  getPageCount: () => number;
+  /**
+   * Resolves the row count used for pagination math.
+   *
+   * `options.rowCount` wins; otherwise the pre-paginated row model is counted.
+   */
+  getRowCount: () => number;
+  /**
+   * Builds zero-based page indexes for the current page count.
+   */
+  getPageOptions: () => Array<number>;
+  /**
+   * Increments the page index by one, if possible.
+   */
+  nextPage: () => void;
+  /**
+   * Decrements the page index by one, if possible.
+   */
+  previousPage: () => void;
+  /**
+   * Sets the page index to `0`.
+   */
+  firstPage: () => void;
+  /**
+   * Sets the page index to the last known page. Does nothing when the page
+   * count is unknown, empty, or non-finite.
+   */
+  lastPage: () => void;
+  /**
+   * Resets `pagination.pageIndex` to initial state, or to `0` when
+   * `defaultState` is `true`.
+   */
+  resetPageIndex: (defaultState?: boolean) => void;
+  /**
+   * Resets `pagination.pageSize` to initial state, or to `10` when
+   * `defaultState` is `true`.
+   */
+  resetPageSize: (defaultState?: boolean) => void;
+  /**
+   * Resets `pagination` to `initialState.pagination`.
+   *
+   * Pass `true` to ignore initial state and reset to
+   * `{ pageIndex: 0, pageSize: 10 }`.
+   */
+  resetPagination: (defaultState?: boolean) => void;
+  /**
+   * Updates `pagination.pageIndex` using a value or updater.
+   */
+  setPageIndex: (updater: Updater<number>) => void;
+  /**
+   * Updates `pagination.pageSize` using a value or updater.
+   */
+  setPageSize: (updater: Updater<number>) => void;
+  /**
+   * Updates pagination state with a next state or updater function.
+   */
+  setPagination: (updater: Updater<PaginationState>) => void;
+}
+interface Table_RowModels_Paginated<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Resolves the row model after pagination has sliced the current page.
+   */
+  getPaginatedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Reads the row model immediately before pagination.
+   */
+  getPrePaginatedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Paginated<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  paginatedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-faceting/columnFacetingFeature.types.d.ts
+//#region src/features/column-faceting/columnFacetingFeature.types.d.ts
+interface Column_ColumnFaceting<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Computes min/max numeric facet values for this column.
+   */
+  getFacetedMinMaxValues: () => undefined | [number, number];
+  /**
+   * Computes the row model used to derive this column's facet values.
+   *
+   * Other column filters are applied, while this column's own filter is
+   * excluded.
+   */
+  getFacetedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Computes unique facet values and occurrence counts for this column.
+   */
+  getFacetedUniqueValues: () => Map<any, number>;
+}
+interface Table_RowModels_Faceted<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Computes min/max numeric facet values for the active faceting context.
+   *
+   * Requires a `facetedMinMaxValues` row-model factory on the `features` option.
+   */
+  getFacetedMinMaxValues: () => undefined | [number, number];
+  /**
+   * Computes the row model used to derive facet values.
+   *
+   * Requires a `facetedRowModel` row-model factory on the `features` option.
+   */
+  getFacetedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Computes unique facet values and occurrence counts.
+   *
+   * Requires a `facetedUniqueValues` row-model factory on the `features` option.
+   */
+  getFacetedUniqueValues: () => Map<any, number>;
+}
+interface CachedRowModel_Faceted<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  facetedRowModels?: Record<string, () => RowModel<TFeatures, TData>>;
+  facetedMinMaxValues?: Record<string, () => undefined | [number, number]>;
+  facetedUniqueValues?: Record<string, () => Map<any, number>>;
+  globalFacetedRowModel?: () => RowModel<TFeatures, TData>;
+  globalFacetedMinMaxValues?: () => undefined | [number, number];
+  globalFacetedUniqueValues?: () => Map<any, number>;
+}
+interface Table_ColumnFaceting<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Returns the min and max values for the global filter.
+   */
+  getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+  /**
+   * Computes the row model used to derive global facet values.
+   */
+  getGlobalFacetedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the faceted unique values for the global filter.
+   */
+  getGlobalFacetedUniqueValues: () => Map<any, number>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/row-models/coreRowModelsFeature.types.d.ts
+//#region src/core/row-models/coreRowModelsFeature.types.d.ts
+interface RowModel<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  rows: Array<Row<TFeatures, TData>>;
+  flatRows: Array<Row<TFeatures, TData>>;
+  rowsById: Record<string, Row<TFeatures, TData>>;
+}
+interface CachedRowModel_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  coreRowModel: () => RowModel<TFeatures, TData>;
+}
+interface Table_RowModels_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Returns the core row model before any processing has been applied.
+   */
+  getCoreRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the final model after all processing from other used features has been applied. This is the row model that is most commonly used for rendering.
+   */
+  getRowModel: () => RowModel<TFeatures, TData>;
+}
+type Table_RowModels<TFeatures extends TableFeatures, TData extends RowData$2> = Table_RowModels_Core<TFeatures, TData> & Table_RowModels_Faceted<TFeatures, TData> & Table_RowModels_Filtered<TFeatures, TData> & Table_RowModels_Grouped<TFeatures, TData> & Table_RowModels_Expanded<TFeatures, TData> & Table_RowModels_Paginated<TFeatures, TData> & Table_RowModels_Sorted<TFeatures, TData>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-grouping/columnGroupingFeature.types.d.ts
+//#region src/features/column-grouping/columnGroupingFeature.types.d.ts
+type GroupingState = Array<string>;
+interface TableState_ColumnGrouping {
+  grouping: GroupingState;
+}
+interface ColumnDef_ColumnGrouping<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Allows this column to be added to grouping state.
+   *
+   * Defaults to `true`; table-level `enableGrouping` must also allow grouping.
+   */
+  enableGrouping?: boolean;
+  /**
+   * Returns the value used to group rows for this column.
+   *
+   * When omitted, grouping uses the value derived from this column's
+   * `accessorKey` or `accessorFn`.
+   */
+  getGroupingValue?: (originalRow: TData, index: number, row: Row<TFeatures, TData>) => any;
+}
+interface Column_ColumnGrouping {
+  /**
+   * Checks whether this column can currently be grouped.
+   */
+  getCanGroup: () => boolean;
+  /**
+   * Finds this column's position in the ordered grouping state.
+   */
+  getGroupedIndex: () => number;
+  /**
+   * Checks whether this column id is present in grouping state.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Returns a function that toggles the grouping state of the column. This is useful for passing to the `onClick` prop of a button.
+   */
+  getToggleGroupingHandler: () => () => void;
+  /**
+   * Toggles the grouping state of the column.
+   */
+  toggleGrouping: () => void;
+}
+interface Row_ColumnGrouping {
+  _groupingValuesCache: Record<string, any>;
+  /**
+   * Reads the value used to group this row for a column id.
+   */
+  getGroupingValue: (columnId: string) => unknown;
+  /**
+   * Checks whether this row represents a grouped row.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * If this row is grouped, this is the id of the column that this row is grouped by.
+   */
+  groupingColumnId?: string;
+  /**
+   * If this row is grouped, this is the unique/shared value for the `groupingColumnId` for all of the rows in this group.
+   */
+  groupingValue?: unknown;
+}
+interface Cell_ColumnGrouping {
+  /**
+   * Checks whether this cell represents the active grouping column.
+   */
+  getIsGrouped: () => boolean;
+  /**
+   * Checks whether this cell is hidden as a grouping placeholder.
+   */
+  getIsPlaceholder: () => boolean;
+}
+interface TableOptions_ColumnGrouping {
+  /**
+   * Allows columns to be grouped for this table.
+   */
+  enableGrouping?: boolean;
+  /**
+   * Grouping columns are automatically reordered by default to the start of the columns list. If you would rather remove them or leave them as-is, set the appropriate mode here.
+   */
+  groupedColumnMode?: false | 'reorder' | 'remove';
+  /**
+   * Enables manual grouping. If this option is set to `true`, the table will not automatically group rows using `getGroupedRowModel()` and instead will expect you to manually group the rows before passing them to the table. This is useful if you are doing server-side grouping and aggregation.
+   */
+  manualGrouping?: boolean;
+  /**
+   * Called with an updater when grouping state changes. Pair this with
+   * `state.grouping` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onGroupingChange?: OnChangeFn<GroupingState>;
+}
+interface Table_ColumnGrouping<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  /**
+   * Resets `grouping` to `initialState.grouping`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetGrouping: (defaultState?: boolean) => void;
+  /**
+   * Updates grouping state with a next ordered id array or updater function.
+   */
+  setGrouping: (updater: Updater<GroupingState>) => void;
+}
+interface Table_RowModels_Grouped<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Resolves the row model after grouping has been applied.
+   */
+  getGroupedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Reads the row model immediately before grouping.
+   */
+  getPreGroupedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Grouped<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  groupedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/global-filtering/globalFilteringFeature.types.d.ts
+//#region src/features/global-filtering/globalFilteringFeature.types.d.ts
+interface TableState_GlobalFiltering {
+  globalFilter: any;
+}
+interface ColumnDef_GlobalFiltering {
+  /**
+   * Allows this column to be scanned by global filtering.
+   *
+   * Defaults to `true`; table-level global filtering and `enableFilters` must
+   * also allow filtering.
+   */
+  enableGlobalFilter?: boolean;
+}
+interface Column_GlobalFiltering {
+  /**
+   * Checks whether this accessor column participates in global filtering.
+   */
+  getCanGlobalFilter: () => boolean;
+}
+interface TableOptions_GlobalFiltering<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Enables global filtering across columns that allow it.
+   */
+  enableGlobalFilter?: boolean;
+  /**
+   * If provided, this function will be called with the column and should return `true` or `false` to indicate whether this column should be used for global filtering.
+   * This is useful if the column can contain data that is not `string` or `number` (i.e. `undefined`).
+   */
+  getColumnCanGlobalFilter?: <TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData>(column: Column$2<TFeatures, TData, TValue>) => boolean;
+  /**
+   * The filter function to use for global filtering.
+   * - A `string` referencing a built-in filter function
+   * - A `string` that references a custom filter functions provided via the `tableOptions.filterFns` option
+   * - A custom filter function
+   */
+  globalFilterFn?: FilterFnOption<TFeatures, TData>;
+  /**
+   * Called with an updater when global filter state changes. Pair this with
+   * `state.globalFilter` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onGlobalFilterChange?: OnChangeFn<any>;
+}
+interface Table_GlobalFiltering<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.
+   */
+  getGlobalAutoFilterFn: () => FilterFn<TFeatures, TData> | undefined;
+  /**
+   * Returns the filter function (either user-defined or automatic, depending on configuration) for the global filter.
+   */
+  getGlobalFilterFn: () => FilterFn<TFeatures, TData> | undefined;
+  /**
+   * Resets `globalFilter` to `initialState.globalFilter`.
+   *
+   * Pass `true` to ignore initial state and reset to `undefined`.
+   */
+  resetGlobalFilter: (defaultState?: boolean) => void;
+  /**
+   * Updates global filter state with a next value or updater function.
+   */
+  setGlobalFilter: (updater: Updater<any>) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-aggregation/aggregationFns.d.ts
+//#region src/features/row-aggregation/aggregationFns.d.ts
+type RangeValue = Date | number;
+/**
+ * Full built-in registry. Register individual definitions for tree-shaking.
+ *
+ * @deprecated Import individual `aggregationFn_*` definitions instead for a
+ * smaller bundle. This registry remains available for compatibility.
+ */
+declare const aggregationFns: {
+  sum: AggregationFnDef<any, any, unknown, number>;
+  min: AggregationFnDef<any, any, unknown, RangeValue | undefined>;
+  max: AggregationFnDef<any, any, unknown, RangeValue | undefined>;
+  extent: AggregationFnDef<any, any, unknown, [RangeValue | undefined, RangeValue | undefined]>;
+  mean: AggregationFnDef<any, any, unknown, number | undefined>;
+  median: AggregationFnDef<any, any, unknown, number | undefined>;
+  unique: AggregationFnDef<any, any, unknown, unknown[]>;
+  uniqueCount: AggregationFnDef<any, any, unknown, number>;
+  count: AggregationFnDef<any, any, unknown, number>;
+  first: AggregationFnDef<any, any, unknown, unknown>;
+  last: AggregationFnDef<any, any, unknown, unknown>;
+};
+type BuiltInAggregationFn = keyof typeof aggregationFns;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-ordering/columnOrderingFeature.types.d.ts
+//#region src/features/column-ordering/columnOrderingFeature.types.d.ts
+type ColumnOrderState = Array<string>;
+interface ColumnIndexes {
+  /**
+   * Maps each visible leaf column id to its index in the full visible column list.
+   */
+  all: Record<string, number>;
+  /**
+   * Maps each unpinned visible leaf column id to its index within the center region.
+   */
+  center: Record<string, number>;
+  /**
+   * Maps each start-pinned visible leaf column id to its index within the start region.
+   */
+  start: Record<string, number>;
+  /**
+   * Maps each end-pinned visible leaf column id to its index within the end region.
+   */
+  end: Record<string, number>;
+}
+interface TableState_ColumnOrdering {
+  columnOrder: ColumnOrderState;
+}
+interface TableOptions_ColumnOrdering {
+  /**
+   * Called with an updater when column order state changes. Pair this with
+   * `state.columnOrder` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+}
+interface Column_ColumnOrdering {
+  /**
+   * Finds this column's zero-based index among visible columns.
+   *
+   * Pass `'start'`, `'center'`, or `'end'` to measure within that pinned
+   * region instead of the full visible leaf order.
+   */
+  getIndex: (position?: ColumnPinningPosition | 'center') => number;
+  /**
+   * Checks whether this column is the first visible column.
+   *
+   * Pass a pinned region to check the first column within that region.
+   */
+  getIsFirstColumn: (position?: ColumnPinningPosition | 'center') => boolean;
+  /**
+   * Checks whether this column is the last visible column.
+   *
+   * Pass a pinned region to check the last column within that region.
+   */
+  getIsLastColumn: (position?: ColumnPinningPosition | 'center') => boolean;
+}
+interface Table_ColumnOrdering<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  /**
+   * Builds column-id to index records for each visible pinning region.
+   *
+   * This is the memoized source that `column.getIndex` reads from; most apps
+   * will not need to call it directly.
+   */
+  getColumnIndexes: () => ColumnIndexes;
+  /**
+   * Resets `columnOrder` to `initialState.columnOrder`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetColumnOrder: (defaultState?: boolean) => void;
+  /**
+   * Updates column order state with a next ordered id array or updater function.
+   */
+  setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/columns/coreColumnsFeature.types.d.ts
+//#region src/core/columns/coreColumnsFeature.types.d.ts
+interface Column_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * 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.
+   */
+  accessorFn?: AccessorFn<TData, TValue>;
+  /**
+   * The original column def used to create the column.
+   */
+  columnDef: ColumnDef$2<TFeatures, TData, TValue>;
+  /**
+   * The child column (if the column is a group column). Will be an empty array if the column is not a group column.
+   */
+  columns: Array<Column$2<TFeatures, TData, TValue>>;
+  /**
+   * The depth of the column (if grouped) relative to the root column def array.
+   */
+  depth: number;
+  /**
+     * 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
+     */
+  id: string;
+  /**
+   * The parent column for this column. Will be undefined if this is a root column.
+   */
+  parent?: Column$2<TFeatures, TData, TValue>;
+  /**
+   * Reference to the parent table instance.
+   */
+  table: Table<TFeatures, TData>;
+}
+interface Column_Column<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> extends Column_CoreProperties<TFeatures, TData, TValue> {
+  /**
+   * Flattens this column and every descendant column into a single array.
+   */
+  getFlatColumns: () => Array<Column$2<TFeatures, TData, TValue>>;
+  /**
+   * Collects the terminal leaf columns below this column, or the column itself
+   * when it has no children.
+   */
+  getLeafColumns: () => Array<Column$2<TFeatures, TData, TValue>>;
+}
+interface TableOptions_Columns<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * The array of column defs to use for the table.
+   */
+  columns: ReadonlyArray<ColumnDef$2<TFeatures, TData, TValue>>;
+  /**
+   * Default column options to use for all column defs supplied to the table.
+   */
+  defaultColumn?: Partial<ColumnDef$2<TFeatures, TData, TValue>>;
+}
+interface Table_Columns<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Returns a map of all flat columns by their ID.
+   */
+  getAllFlatColumnsById: () => Record<string, Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Resolves built-in, feature-level, and user-defined default column options.
+   */
+  getDefaultColumnDef: () => Partial<ColumnDef$2<TFeatures, TData, unknown>>;
+  /**
+   * Normalizes `options.columns` into the table's nested column hierarchy.
+   */
+  getAllColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Flattens the nested column hierarchy, including parent/group columns.
+   */
+  getAllFlatColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Collects all terminal leaf columns, excluding parent/group columns.
+   */
+  getAllLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Returns a map of all leaf-node columns by their ID. This does not include parent columns.
+   */
+  getAllLeafColumnsById: () => Record<string, Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Returns a single column by its ID.
+   */
+  getColumn: (columnId: string) => Column$2<TFeatures, TData, unknown> | undefined;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-visibility/columnVisibilityFeature.types.d.ts
+//#region src/features/column-visibility/columnVisibilityFeature.types.d.ts
+type ColumnVisibilityState = Record<string, boolean>;
+interface TableState_ColumnVisibility {
+  columnVisibility: ColumnVisibilityState;
+}
+interface TableOptions_ColumnVisibility {
+  /**
+   * Whether to enable column hiding. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+  /**
+   * Called with an updater when column visibility state changes. Pair this with
+   * `state.columnVisibility` when using external state; external atoms can own
+   * the slice without this callback.
+   */
+  onColumnVisibilityChange?: OnChangeFn<ColumnVisibilityState>;
+}
+interface Table_ColumnVisibility<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Checks whether every leaf column is currently visible.
+   */
+  getIsAllColumnsVisible: () => boolean;
+  /**
+   * Checks whether at least one leaf column is currently visible.
+   */
+  getIsSomeColumnsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that shows or hides all columns.
+   */
+  getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Lists visible columns in flat table order, including parent columns that
+   * have visible descendants.
+   */
+  getVisibleFlatColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the order used for row cells and headers.
+   */
+  getVisibleLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Resets `columnVisibility` to `initialState.columnVisibility`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
+   */
+  resetColumnVisibility: (defaultState?: boolean) => void;
+  /**
+   * Updates column visibility state with a next map or updater function.
+   */
+  setColumnVisibility: (updater: Updater<ColumnVisibilityState>) => void;
+  /**
+   * Toggles the visibility of all columns.
+   */
+  toggleAllColumnsVisible: (value?: boolean) => void;
+}
+interface ColumnDef_ColumnVisibility {
+  /**
+   * Allows this column to be hidden. Defaults to `true`.
+   */
+  enableHiding?: boolean;
+}
+interface Row_ColumnVisibility<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Gets this row's cells for currently visible columns.
+   */
+  getVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Maps this row's currently visible cells by column id.
+   */
+  getVisibleCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>;
+}
+interface Column_ColumnVisibility {
+  /**
+   * Checks whether this column is allowed to be hidden.
+   */
+  getCanHide: () => boolean;
+  /**
+   * Checks whether this column is currently visible.
+   */
+  getIsVisible: () => boolean;
+  /**
+   * Creates a checkbox-style handler that toggles this column's visibility.
+   */
+  getToggleVisibilityHandler: () => (event: unknown) => void;
+  /**
+   * Toggles the visibility of the column.
+   */
+  toggleVisibility: (value?: boolean) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-pinning/rowPinningFeature.types.d.ts
+//#region src/features/row-pinning/rowPinningFeature.types.d.ts
+type RowPinningPosition = false | 'top' | 'bottom';
+interface RowPinningState {
+  bottom: Array<string>;
+  top: Array<string>;
+}
+interface TableState_RowPinning {
+  rowPinning: RowPinningState;
+}
+interface TableOptions_RowPinning<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Allows rows to be pinned to top or bottom regions.
+   *
+   * Provide a predicate to decide per row. Defaults to `true`.
+   */
+  enableRowPinning?: boolean | ((row: Row<TFeatures, TData>) => boolean);
+  /**
+   * When `false`, pinned rows will not be visible if they are filtered or paginated out of the table. When `true`, pinned rows will always be visible regardless of filtering or pagination. Defaults to `true`.
+   */
+  keepPinnedRows?: boolean;
+  /**
+   * Called with an updater when row pinning state changes. Pair this with
+   * `state.rowPinning` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onRowPinningChange?: OnChangeFn<RowPinningState>;
+}
+interface Row_RowPinning {
+  /**
+   * Checks whether this row can be pinned.
+   */
+  getCanPin: () => boolean;
+  /**
+   * Returns the pinned position of the row. (`'top'`, `'bottom'` or `false`)
+   */
+  getIsPinned: () => RowPinningPosition;
+  /**
+   * Returns the numeric pinned index of the row within a pinned row group.
+   */
+  getPinnedIndex: () => number;
+  /**
+   * Pins a row to the `'top'` or `'bottom'`, or unpins the row to the center if `false` is passed.
+   */
+  pin: (position: RowPinningPosition, includeLeafRows?: boolean, includeParentRows?: boolean) => void;
+}
+interface Table_RowPinning<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Gets rows pinned to the bottom region.
+   */
+  getBottomRows: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Gets rows that are not pinned to the top or bottom region.
+   */
+  getCenterRows: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Checks whether any rows are pinned, optionally limited to one region.
+   */
+  getIsSomeRowsPinned: (position?: RowPinningPosition) => boolean;
+  /**
+   * Gets rows pinned to the top region.
+   */
+  getTopRows: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Resets `rowPinning` to `initialState.rowPinning`.
+   *
+   * Pass `true` to ignore initial state and reset to empty top/bottom arrays.
+   */
+  resetRowPinning: (defaultState?: boolean) => void;
+  /**
+   * Updates row pinning state with a next state or updater function.
+   */
+  setRowPinning: (updater: Updater<RowPinningState>) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-selection/rowSelectionFeature.types.d.ts
+//#region src/features/row-selection/rowSelectionFeature.types.d.ts
+type RowSelectionState = Record<string, true>;
+/**
+ * Controls how toggling a row affects its descendants and ancestors.
+ */
+interface ToggleSelectedOptions {
+  /**
+   * Whether selectable child rows should be toggled recursively. Defaults to
+   * `true`.
+   */
+  selectChildren?: boolean;
+  /**
+   * Whether ancestor row ids should be removed from the selection when this
+   * row is deselected. Useful after a parent cascade wrote the parent id into
+   * state and a child is later deselected. Defaults to `false`.
+   *
+   * Ancestor ids are removed even when the ancestor itself cannot be selected.
+   * Like the other targeted deselection paths, pruning is not gated by
+   * `enableRowSelection`; only the bulk select-all paths preserve
+   * non-selectable rows.
+   */
+  deselectParents?: boolean;
+}
+interface TableState_RowSelection {
+  rowSelection: RowSelectionState;
+}
+interface TableOptions_RowSelection<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Enables inclusive row range selection through
+   * `row.getToggleSelectedHandler()`. Defaults to `true`.
+   */
+  enableRowRangeSelection?: boolean;
+  /**
+   * Allows rows to be selected alongside other rows.
+   *
+   * Provide a predicate to decide per row. Defaults to `true`.
+   */
+  enableMultiRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean);
+  /**
+   * Allows rows to be selected.
+   *
+   * Provide a predicate to decide per row. Defaults to `true`.
+   */
+  enableRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean);
+  /**
+   * Controls whether selecting a parent row also selects its subRows.
+   *
+   * Provide a predicate to decide per row. This is most useful with expanding or
+   * grouping features and defaults to `true`. Select-all and the all-selected
+   * getters also skip descendants of parents that block sub-row selection.
+   */
+  enableSubRowSelection?: boolean | ((row: Row<TFeatures, TData>) => boolean);
+  /**
+   * Determines whether a row-selection handler event should select or
+   * deselect the inclusive range from the most recent handler interaction.
+   *
+   * By default, events with `shiftKey` directly on the event or on
+   * `event.nativeEvent` are treated as range-selection events.
+   */
+  isRowRangeSelectionEvent?: (event: unknown) => boolean;
+  /**
+   * Called with an updater when row selection state changes. Pair this with
+   * `state.rowSelection` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+}
+interface Row_RowSelection {
+  /**
+   * Checks whether this row can be selected alongside other rows.
+   */
+  getCanMultiSelect: () => boolean;
+  /**
+   * Checks whether this row can currently be selected.
+   */
+  getCanSelect: () => boolean;
+  /**
+   * Checks whether selecting this row should also select its subRows.
+   */
+  getCanSelectSubRows: () => boolean;
+  /**
+   * Checks whether all selectable descendants are selected.
+   */
+  getIsAllSubRowsSelected: () => boolean;
+  /**
+   * Checks whether this row id is selected.
+   */
+  getIsSelected: () => boolean;
+  /**
+   * Checks whether some selectable descendants are selected.
+   */
+  getIsSomeSelected: () => boolean;
+  /**
+   * Creates a checkbox-style handler that toggles this row's selected state.
+   * Pass the original checkbox click event, or a framework event whose
+   * `nativeEvent` is that click, so Shift range selection can detect the
+   * modifier key.
+   */
+  getToggleSelectedHandler: (opts?: ToggleSelectedOptions) => (event: unknown) => void;
+  /**
+   * Selects/deselects the row.
+   */
+  toggleSelected: (value?: boolean, opts?: ToggleSelectedOptions) => void;
+}
+interface Table_RowSelection<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * The most recent row interacted with through the row selection handler.
+   *
+   * @internal
+   */
+  _lastSelectedRowId: string | null;
+  /**
+   * Builds a selected-row model from rows after filtering.
+   */
+  getFilteredSelectedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Builds a selected-row model from rows after grouping.
+   */
+  getGroupedSelectedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Returns the ids of all selected rows.
+   */
+  getSelectedRowIds: () => Array<string>;
+  /**
+   * Checks whether every selectable row on the current page is selected.
+   * Sub-rows whose ancestors block sub-row selection are ignored.
+   */
+  getIsAllPageRowsSelected: () => boolean;
+  /**
+   * Checks whether every selectable filtered row is selected.
+   * Sub-rows whose ancestors block sub-row selection are ignored.
+   */
+  getIsAllRowsSelected: () => boolean;
+  /**
+   * Checks whether at least one selectable row on the current page is selected.
+   */
+  getIsSomePageRowsSelected: () => boolean;
+  /**
+   * Checks whether at least one row id is selected.
+   */
+  getIsSomeRowsSelected: () => boolean;
+  /**
+   * Returns the core row model of all rows before row selection has been applied.
+   */
+  getPreSelectedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Builds a selected-row model from the core row model.
+   */
+  getSelectedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Creates a checkbox-style handler that toggles all current-page rows.
+   */
+  getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
+  /**
+   * Creates a checkbox-style handler that toggles all selectable rows.
+   */
+  getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
+  /**
+   * Resets `rowSelection` to `initialState.rowSelection`.
+   *
+   * Pass `true` to ignore initial state and reset to `{}`.
+   */
+  resetRowSelection: (defaultState?: boolean) => void;
+  /**
+   * Updates row selection state with a next map or updater function.
+   */
+  setRowSelection: (updater: Updater<RowSelectionState>) => void;
+  /**
+   * Selects/deselects all rows on the current page.
+   */
+  toggleAllPageRowsSelected: (value?: boolean, opts?: {
+    deselectAll?: boolean;
+  }) => void;
+  /**
+   * Selects/deselects all rows in the table.
+   *
+   * Deselecting keeps rows that cannot be selected in the selection map unless
+   * `opts.deselectAll` is `true`.
+   */
+  toggleAllRowsSelected: (value?: boolean, opts?: {
+    deselectAll?: boolean;
+  }) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/rows/coreRowsFeature.types.d.ts
+//#region src/core/rows/coreRowsFeature.types.d.ts
+interface Row_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  _cellsCache?: WeakMap<Column$2<TFeatures, TData, unknown>, Cell<TFeatures, TData, unknown>>;
+  /**
+   * Internal cache used while resolving the current display order.
+   *
+   * This value may be stale until display order is recomputed. Use
+   * `row.getDisplayIndex()` instead; it refreshes and validates the cached
+   * position before returning it.
+   *
+   * @internal
+   */
+  _displayIndexCache: number;
+  _uniqueValuesCache: Record<string, unknown>;
+  _valuesCache: Record<string, unknown>;
+  /**
+   * The depth of the row (if nested or grouped) relative to the root row array.
+   */
+  depth: number;
+  /**
+   * The resolved unique identifier for the row resolved via the `options.getRowId` option. Defaults to the row's index (or relative index if it is a subRow).
+   */
+  id: string;
+  /**
+   * The index of the row within its parent array (or the root data array).
+   */
+  index: number;
+  /**
+   * The original row object provided to the table. If the row is a grouped row, the original row object will be the first original in the group.
+   */
+  original: TData;
+  /**
+   * An array of the original subRows as returned by the `options.getSubRows` option.
+   */
+  originalSubRows?: ReadonlyArray<TData>;
+  /**
+   * If nested, this row's parent row id.
+   */
+  parentId?: string;
+  /**
+   * An array of subRows for the row as returned and created by the `options.getSubRows` option.
+   */
+  subRows: Array<Row<TFeatures, TData>>;
+  /**
+   * Reference to the parent table instance.
+   */
+  table: Table<TFeatures, TData>;
+}
+interface Row_Row<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends Row_CoreProperties<TFeatures, TData> {
+  /**
+   * Returns the zero-based index of the row in the current display order
+   * before pagination, or `-1` if the row is not in that model. Use this for
+   * display row-number columns instead of `row.index` or the internal
+   * `_displayIndexCache` field.
+   */
+  getDisplayIndex: () => number;
+  /**
+   * Builds a lookup of this row's cells keyed by leaf column id.
+   */
+  getAllCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>;
+  /**
+   * Builds one cell for each leaf column, including cells for hidden columns.
+   */
+  getAllCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Returns the leaf rows for the row, not including any parent rows.
+   */
+  getLeafRows: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Returns the parent row for the row, if it exists.
+   */
+  getParentRow: () => Row<TFeatures, TData> | undefined;
+  /**
+   * Returns the parent rows for the row, all the way up to a root row.
+   */
+  getParentRows: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Reads the values this row contributes to faceting/grouping for a column.
+   */
+  getUniqueValues: <TValue>(columnId: string) => Array<TValue>;
+  /**
+   * Reads this row's accessor value for a column id and caches the result.
+   */
+  getValue: <TValue>(columnId: string) => TValue;
+  /**
+   * Renders the value for the row in a given columnId the same as `getValue`, but will return the `renderFallbackValue` if no value is found.
+   */
+  renderValue: <TValue>(columnId: string) => TValue;
+}
+interface TableOptions_Rows<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * This optional function is used to derive a unique ID for any given row. If not provided the row's index is used (nested rows join together with `.` using their grandparents' index e.g. `index.index.index`). If you need to identify individual rows that are originating from any server-side operations, it's suggested you use this function to return an ID that makes sense regardless of network IO/ambiguity e.g. a userId, taskId, database ID field, etc.
+   * @example getRowId: row => row.userId
+   */
+  getRowId?: (originalRow: TData, index: number, parent?: Row<TFeatures, TData>) => string;
+  /**
+   * This optional function is used to access the sub rows for any given row. If you are using nested rows, you will need to use this function to return the sub rows object (or undefined) from the row.
+   * @example getSubRows: row => row.subRows
+   */
+  getSubRows?: (originalRow: TData, index: number) => undefined | ReadonlyArray<TData>;
+}
+interface Table_Rows<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Returns the deepest structural row depth in the core row model.
+   * Root rows are depth `0`, direct sub-rows are depth `1`, and so on.
+   */
+  getMaxSubRowDepth: () => number;
+  /**
+   * Returns the rows in the current display order and assigns their display
+   * indexes. When expanded rows bypass pagination, expanded descendants are
+   * included in this order. This is the memoized source for
+   * `row.getDisplayIndex()`.
+   */
+  getRowsInDisplayOrder: () => Array<Row<TFeatures, TData>>;
+  /**
+   * Returns the row id for a given row.
+   */
+  getRowId: (_: TData, index: number, parent?: Row<TFeatures, TData>) => string;
+  /**
+   * Returns the row with the given ID.
+   */
+  getRow: (id: string, searchAll?: boolean) => Row<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/RowModel.d.ts
+//#region src/types/RowModel.d.ts
+interface CachedRowModels_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  columnFacetingFeature: CachedRowModel_Faceted<TFeatures, TData>;
+  columnFilteringFeature: CachedRowModel_Filtered<TFeatures, TData>;
+  rowExpandingFeature: CachedRowModel_Expanded<TFeatures, TData>;
+  columnGroupingFeature: CachedRowModel_Grouped<TFeatures, TData>;
+  rowPaginationFeature: CachedRowModel_Paginated<TFeatures, TData>;
+  rowSortingFeature: CachedRowModel_Sorted<TFeatures, TData>;
+}
+type CachedRowModels<TFeatures extends TableFeatures, TData extends RowData$2> = Partial<CachedRowModel_Core<TFeatures, TData>> & ExtractFeatureMapTypes<TFeatures, CachedRowModels_FeatureMap<TFeatures, TData>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/RowModelFns.d.ts
+interface RowModelFns_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  rowAggregationFeature: RowModelFns_RowAggregation<TFeatures, TData>;
+  columnFilteringFeature: RowModelFns_ColumnFiltering<TFeatures, TData>;
+  rowSortingFeature: RowModelFns_RowSorting<TFeatures, TData>;
+}
+type RowModelFns<TFeatures extends TableFeatures, TData extends RowData$2> = Partial<ExtractFeatureMapTypes<TFeatures, RowModelFns_FeatureMap<TFeatures, TData>>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/TableState.d.ts
+//#region src/types/TableState.d.ts
+interface TableState_FeatureMap {
+  cellSelectionFeature: TableState_CellSelection;
+  columnFilteringFeature: TableState_ColumnFiltering;
+  columnGroupingFeature: TableState_ColumnGrouping;
+  columnOrderingFeature: TableState_ColumnOrdering;
+  columnPinningFeature: TableState_ColumnPinning;
+  columnResizingFeature: TableState_ColumnResizing;
+  columnSizingFeature: TableState_ColumnSizing;
+  columnVisibilityFeature: TableState_ColumnVisibility;
+  globalFilteringFeature: TableState_GlobalFiltering;
+  rowExpandingFeature: TableState_RowExpanding;
+  rowPaginationFeature: TableState_RowPagination;
+  rowPinningFeature: TableState_RowPinning;
+  rowSelectionFeature: TableState_RowSelection;
+  rowSortingFeature: TableState_RowSorting;
+}
+/**
+ * Complete table state for a specific feature set.
+ *
+ * State slices are included only when their feature is present in `TFeatures`,
+ * then custom feature/plugin state is mixed in.
+ */
+type TableState<TFeatures extends TableFeatures> = ExtractFeatureMapTypes<TFeatures, TableState_FeatureMap>;
+/**
+ * Internal broad state shape containing every registered feature state slice.
+ *
+ * Feature internals use this when they may need to inspect optional slices owned
+ * by other features.
+ */
+interface TableState_All extends Partial<TableState_CellSelection & TableState_ColumnFiltering & TableState_ColumnGrouping & TableState_ColumnOrdering & TableState_ColumnPinning & TableState_ColumnResizing & TableState_ColumnSizing & TableState_ColumnVisibility & TableState_GlobalFiltering & TableState_RowExpanding & TableState_RowPagination & TableState_RowPinning & TableState_RowSelection & TableState_RowSorting> {}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/cell-spanning/cellSpanningFeature.types.d.ts
+//#region src/features/cell-spanning/cellSpanningFeature.types.d.ts
+/**
+ * The table's cell span index for the rows that are currently rendered.
+ *
+ * Cell APIs read this; it is exposed for devtools and for virtualizers that
+ * need to know where a run's anchor sits relative to the rendered window.
+ */
+interface CellSpanIndex<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Column spans per render-order row position, indexed by render-order column
+   * position. Holes are the common case: only rows that declared a column span
+   * get an array. In a stored array, the spanning cell holds its span and the
+   * cells it covers hold `0`; every other cell holds `1`.
+   */
+  colSpans: Array<Int32Array | undefined>;
+  /**
+   * Render-order index for every visible column id. Hidden columns are absent.
+   */
+  columnIndexes: Record<string, number>;
+  /**
+   * Row spans per column id, indexed by render-order row position. Only columns
+   * that produced at least one run longer than one row appear here; a missing
+   * column means every cell in it spans exactly one row. In a stored array, the
+   * run's anchor row holds the run length and the rows it covers hold `0`.
+   */
+  rowSpans: Record<string, Int32Array>;
+  /**
+   * The exact ordered rows this index was built from, in render order:
+   * top-pinned rows, then the (paginated) center rows, then bottom-pinned
+   * rows. Cell reads compare against this to reject stale row positions.
+   */
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/**
+ * Context passed to a `spanRows` predicate for each candidate row.
+ *
+ * The run is anchored: `anchorRow` is the row whose cell will render the
+ * merged content, and every later row in the run is tested against it, which
+ * keeps runs transitive by construction. `previousRow` is provided for
+ * predicates that want a step-wise comparison instead.
+ */
+interface RowSpanContext<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  anchorRow: Row<TFeatures, TData>;
+  anchorValue: TValue;
+  column: Column$2<TFeatures, TData, TValue>;
+  previousRow: Row<TFeatures, TData>;
+  row: Row<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
+  value: TValue;
+}
+/**
+ * Context passed to a `spanColumns` resolver for each rendered row.
+ */
+interface ColSpanContext<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  column: Column$2<TFeatures, TData, TValue>;
+  row: Row<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
+}
+interface ColumnDef_CellSpanning<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * Turns this column off for cell spanning even when the table allows it.
+   * Defaults to `true`.
+   */
+  enableCellSpanning?: boolean;
+  /**
+   * Makes this column's cell span the given number of columns per row,
+   * starting at itself and counted in the order columns actually render.
+   *
+   * Return `1` or less for no span. Larger values are clamped to the end of
+   * the cell's pinned region, so a span can never cross the start-pinned,
+   * center, or end-pinned boundary; pass `Infinity` for "the rest of my
+   * region". Hidden columns are not counted.
+   *
+   * @example
+   * ```ts
+   * { accessorKey: 'label', spanColumns: ({ row }) => row.original.isSummary ? Infinity : 1 }
+   * ```
+   */
+  spanColumns?: number | ((context: ColSpanContext<TFeatures, TData, TValue>) => number);
+  /**
+   * Merges adjacent rows in this column into a single vertically spanning
+   * cell.
+   *
+   * `true` merges rows whose values for this column are the same value
+   * (`Object.is`). Nullish values never merge under the default comparison.
+   *
+   * A predicate replaces the comparison entirely and decides whether `row`
+   * joins the run anchored at `anchorRow`; it may merge nullish values. It is
+   * called once per candidate row each time the span index rebuilds, and each
+   * call allocates one context object, so keep it cheap.
+   *
+   * Spans are always recomputed from the rows that are actually rendered, so
+   * sorting, filtering, and paging only change which rows are adjacent. Runs
+   * never cross a page boundary, a pinned-row section boundary, a change of
+   * position in the row tree, or a grouped row. Ignored while this column is
+   * grouped.
+   *
+   * @example
+   * ```ts
+   * { accessorKey: 'department', spanRows: true }
+   * ```
+   */
+  spanRows?: boolean | ((context: RowSpanContext<TFeatures, TData, TValue>) => boolean);
+}
+interface TableOptions_CellSpanning {
+  /**
+   * Allows cells to span rows or columns. When `false` every cell reports a
+   * span of `1` and the span index is never built. Defaults to `true`.
+   */
+  enableCellSpanning?: boolean;
+}
+interface Cell_CellSpanning {
+  /**
+   * Number of columns this cell spans when rendered. `1` when it does not
+   * span, and `0` when another cell's column span covers it.
+   *
+   * Never render a `0` as a `colSpan` attribute; skip the cell instead. See
+   * `getIsCovered`.
+   */
+  getColSpan: () => number;
+  /**
+   * Whether another cell's span covers this cell. Skip rendering covered
+   * cells; the cell that covers them carries the content and the span
+   * attributes.
+   */
+  getIsCovered: () => boolean;
+  /**
+   * Number of rows this cell spans when rendered. `1` when it does not span,
+   * and `0` when a spanning cell above it covers it, matching the
+   * `header.rowSpan` convention.
+   *
+   * Never render a `0` as a `rowSpan` attribute: in HTML, `rowspan="0"` means
+   * "span to the end of the row group", which merges the cell down the entire
+   * table section. Skip the cell instead. See `getIsCovered`.
+   */
+  getRowSpan: () => number;
+}
+interface Table_CellSpanning<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * The memoized span index for the rows that are currently rendered.
+   */
+  getCellSpanIndex: () => CellSpanIndex<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/TableOptions.d.ts
+//#region src/types/TableOptions.d.ts
+/**
+ * Core options that are always available on a table, before optional feature
+ * options are mixed in.
+ */
+interface TableOptions_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends TableOptions_Table<TFeatures, TData>, TableOptions_Cell, TableOptions_Columns<TFeatures, TData>, TableOptions_Rows<TFeatures, TData> {}
+type DebugKeysFor<TFeatures extends TableFeatures> = { [K in Exclude<keyof TFeatures & string, NonFeatureKeys> as `debug${Capitalize<K>}`]?: boolean; };
+type DebugOptions<TFeatures extends TableFeatures> = {
+  debugAll?: boolean;
+  debugCache?: boolean;
+  debugCells?: boolean;
+  debugColumns?: boolean;
+  debugHeaders?: boolean;
+  debugRows?: boolean;
+  debugTable?: boolean;
+} & DebugKeysFor<CoreFeatures & TFeatures>;
+interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  cellSelectionFeature: TableOptions_CellSelection<TFeatures, TData>;
+  cellSpanningFeature: TableOptions_CellSpanning;
+  columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>;
+  columnGroupingFeature: TableOptions_ColumnGrouping;
+  columnOrderingFeature: TableOptions_ColumnOrdering;
+  columnPinningFeature: TableOptions_ColumnPinning;
+  columnResizingFeature: TableOptions_ColumnResizing;
+  columnSizingFeature: TableOptions_ColumnSizing;
+  columnVisibilityFeature: TableOptions_ColumnVisibility;
+  globalFilteringFeature: TableOptions_GlobalFiltering<TFeatures, TData>;
+  rowAggregationFeature: TableOptions_RowAggregation;
+  rowExpandingFeature: TableOptions_RowExpanding<TFeatures, TData>;
+  rowPaginationFeature: TableOptions_RowPagination;
+  rowPinningFeature: TableOptions_RowPinning<TFeatures, TData>;
+  rowSelectionFeature: TableOptions_RowSelection<TFeatures, TData>;
+  rowSortingFeature: TableOptions_RowSorting;
+}
+type TableOptions_StockFeatureKeys = 'cellSelectionFeature' | 'cellSpanningFeature' | 'columnFilteringFeature' | 'columnGroupingFeature' | 'columnOrderingFeature' | 'columnPinningFeature' | 'columnResizingFeature' | 'columnSizingFeature' | 'columnVisibilityFeature' | 'globalFilteringFeature' | 'rowAggregationFeature' | 'rowExpandingFeature' | 'rowPaginationFeature' | 'rowPinningFeature' | 'rowSelectionFeature' | 'rowSortingFeature';
+/**
+ * Plugin entries declaration-merged into `TableOptions_FeatureMap`, i.e. keys
+ * beyond the stock set. Resolves to `unknown` (an intersection no-op) when no
+ * plugins are merged so the common case skips the union-to-intersection work.
+ */
+type TableOptions_PluginFeatureMapTypes<TFeatures extends TableFeatures, TData extends RowData$2> = [Exclude<keyof TableOptions_FeatureMap<TFeatures, TData>, TableOptions_StockFeatureKeys>] extends [never] ? unknown : UnionToIntersection<TableOptions_FeatureMap<TFeatures, TData>[Exclude<keyof TableOptions_FeatureMap<TFeatures, TData>, TableOptions_StockFeatureKeys>]>;
+/**
+ * Complete table options for a specific feature set.
+ *
+ * Feature options are included only when their feature is present in
+ * `TFeatures`, then custom feature/plugin options and debug options are mixed
+ * in.
+ */
+type TableOptions<TFeatures extends TableFeatures, TData extends RowData$2> = TableOptions_Core<TFeatures, TData> & ExtractFeatureMapTypes<TFeatures, TableOptions_FeatureMap<TFeatures, TData>> & DebugOptions<TFeatures>;
+/**
+ * Internal broad option shape used where feature code may need to read options
+ * from features that are not present in the current generic feature set.
+ */
+type TableOptions_All<TFeatures extends TableFeatures, TData extends RowData$2> = TableOptions_Core<TFeatures, TData> & Partial<TableOptions_RowAggregation & TableOptions_CellSelection<TFeatures, TData> & TableOptions_CellSpanning & TableOptions_ColumnFiltering<TFeatures, TData> & TableOptions_ColumnGrouping & TableOptions_ColumnOrdering & TableOptions_ColumnPinning & TableOptions_ColumnResizing & TableOptions_ColumnSizing & TableOptions_ColumnVisibility & TableOptions_GlobalFiltering<TFeatures, TData> & TableOptions_RowExpanding<TFeatures, TData> & TableOptions_RowPagination & TableOptions_RowPinning<TFeatures, TData> & TableOptions_RowSelection<TFeatures, TData> & TableOptions_RowSorting & TableOptions_PluginFeatureMapTypes<TFeatures, TData>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/table/coreTablesFeature.types.d.ts
+//#region src/core/table/coreTablesFeature.types.d.ts
+interface TableMeta<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {}
+/**
+ * Resolves the type of `options.meta` for a feature set.
+ *
+ * When the features object declares a `tableMeta` type-only slot
+ * (`tableFeatures({ ..., tableMeta: {} as MyTableMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `TableMeta`
+ * interface.
+ */
+type ExtractTableMeta<TFeatures extends TableFeatures, TData extends RowData$2> = IsAny<TFeatures> extends true ? TableMeta<TFeatures, TData> : TFeatures extends {
+  tableMeta: infer TMeta extends object;
+} ? TMeta : TableMeta<TFeatures, TData>;
+/**
+ * A map of writable atoms, one per `TableState` slice. These are the internal
+ * writable atoms that the library always writes to via `makeStateUpdater`.
+ */
+type BaseAtoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: Atom<TableState<TFeatures>[K]>; };
+/**
+ * A map of readonly derived atoms, one per `TableState` slice. Each derives
+ * from its corresponding `baseAtom` plus, optionally, a per-slice external
+ * atom or external state value.
+ *
+ * Precedence: `options.atoms[key]` > `options.state[key]` > `baseAtoms[key]`.
+ */
+type Atoms<TFeatures extends TableFeatures> = { [K in keyof TableState<TFeatures>]-?: ReadonlyAtom<TableState<TFeatures>[K]>; };
+/**
+ * A map of optional external atoms, one per `TableState` slice. Consumers can
+ * provide their own writable atom for any state slice to take over ownership
+ * of that slice.
+ */
+type ExternalAtoms<TFeatures extends TableFeatures> = Partial<{ [K in keyof TableState<TFeatures>]: Atom<TableState<TFeatures>[K]>; }>;
+interface TableOptions_Table<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * The feature modules registered on this table instance.
+   *
+   * Feature registration controls which state slices, options, and prototype
+   * APIs are available. This object also carries the table's row model
+   * factories (`sortedRowModel`, `filteredRowModel`, etc.), row model function
+   * registries (`sortFns`, `filterFns`, `aggregationFns`), and type-only meta
+   * slots (`tableMeta`, `columnMeta`).
+   */
+  readonly features: TFeatures & ValidateFeatureSlots<TFeatures>;
+  /**
+   * Optionally, provide your own external writable atoms for individual state slices.
+   * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
+   * and the internal base atom for that slice. Feature state update APIs write through
+   * the corresponding atom updater, so external atoms are the preferred v9 ownership
+   * model for app-managed table state slices.
+   */
+  readonly atoms?: ExternalAtoms<TFeatures>;
+  /**
+   * Set this option to override any of the `autoReset...` feature options.
+   */
+  readonly autoResetAll?: boolean;
+  /**
+   * The data for the table to display. When the `data` option changes reference, the table will reprocess the data.
+   */
+  readonly data: ReadonlyArray<TData>;
+  /**
+   * Optional key used to identify this table instance.
+   *
+   * This is used by TanStack Table Devtools to register and select tables. It is
+   * not required unless the table is passed to devtools.
+   */
+  readonly key?: string;
+  /**
+   * Optionally provide starting values for registered table state slices.
+   * Feature reset APIs use this value by default, and many reset APIs accept
+   * `true` to reset to that feature's blank/default state instead. Changing this
+   * object later does not reset table state, so it does not need to be stable.
+   */
+  readonly initialState?: Partial<TableState<TFeatures>>;
+  /**
+   * This option is used to optionally implement the merging of table options.
+   */
+  readonly mergeOptions?: (defaultOptions: TableOptions<TFeatures, TData>, options: Partial<TableOptions<TFeatures, TData>>) => TableOptions<TFeatures, TData>;
+  /**
+   * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   *
+   * Declare its type per-table via the `tableMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `TableMeta`.
+   */
+  readonly meta?: ExtractTableMeta<TFeatures, TData>;
+  /**
+   * Optionally provide externally managed values for individual state slices.
+   *
+   * Pair each slice with its matching `on[State]Change` callback so table state
+   * updates can be persisted outside the table. External atoms take precedence
+   * over this option when both are provided for the same slice.
+   */
+  readonly state?: Partial<TableState<TFeatures>>;
+}
+interface Table_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Table reactivity bindings for interacting with TanStack Store.
+   */
+  readonly _reactivity: TableReactivityBindings;
+  /**
+   * Cache of the `initCellInstanceData` functions for features that define one.
+   */
+  _cellInstanceInitFns: Array<NonNullable<TableFeature['initCellInstanceData']>>;
+  /**
+   * Prototype cache for Cell objects - shared by all cells in this table
+   */
+  _cellPrototype?: object;
+  /**
+   * Cache of the `initColumnInstanceData` functions for features that define one.
+   */
+  _columnInstanceInitFns: Array<NonNullable<TableFeature['initColumnInstanceData']>>;
+  /**
+   * Prototype cache for Column objects - shared by all columns in this table
+   */
+  _columnPrototype?: object;
+  /**
+   * The features that are enabled for the table.
+   */
+  readonly _features: Partial<CoreFeatures> & TFeatures;
+  /**
+   * Cache of the `initHeaderGroupInstanceData` functions for features that define one.
+   */
+  _headerGroupInstanceInitFns: Array<NonNullable<TableFeature['initHeaderGroupInstanceData']>>;
+  /**
+   * Cache of the `initHeaderInstanceData` functions for features that define one.
+   */
+  _headerInstanceInitFns: Array<NonNullable<TableFeature['initHeaderInstanceData']>>;
+  /**
+   * Prototype cache for Header objects - shared by all headers in this table
+   */
+  _headerPrototype?: object;
+  /**
+   * The row model processing functions that are used to process the data by features.
+   */
+  readonly _rowModelFns: RowModelFns<TFeatures, TData>;
+  /**
+   * The row models that are enabled for the table.
+   */
+  readonly _rowModels: CachedRowModels<TFeatures, TData>;
+  /**
+   * Prototype cache for Row objects - shared by all rows in this table
+   */
+  _rowPrototype?: object;
+  /**
+   * Cache of the `initRowInstanceData` functions for features that define one.
+   */
+  _rowInstanceInitFns: Array<NonNullable<TableFeature['initRowInstanceData']>>;
+  /**
+   * The readonly derived atoms for each `TableState` slice. Each derives from
+   * its corresponding `baseAtom` plus, optionally, a per-slice external atom or
+   * external state value (precedence: external atom > external state > base atom).
+   */
+  readonly atoms: Atoms<TFeatures>;
+  /**
+   * The internal writable atoms for each `TableState` slice. This is the library's
+   * single write surface — all state mutations from features land here.
+   */
+  readonly baseAtoms: BaseAtoms<TFeatures>;
+  /**
+   * This is the resolved initial state of the table.
+   */
+  readonly initialState: TableState<TFeatures>;
+  /**
+   * A read-only reference to the table's current options.
+   */
+  readonly options: TableOptions<TFeatures, TData>;
+  /**
+   * Writable atom for table options. Only created when `createOptionsStore` is
+   * true on the active core reactivity bindings. Adapters that opt out keep
+   * options as plain resolved data instead of backing them with an atom.
+   */
+  readonly optionsStore?: Atom<TableOptions<TFeatures, TData>> | undefined;
+  /**
+   * The readonly flat store for the table state. Derives from `table.atoms`
+   * only; never reads external state directly.
+   */
+  readonly store: ReadonlyStore<TableState<TFeatures>>;
+}
+interface Table_Table<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends Table_CoreProperties<TFeatures, TData> {
+  /**
+   * Resets the table's internal base atoms to `table.initialState`.
+   *
+   * Prefer feature-specific reset APIs, such as `resetPagination`, when a state
+   * slice may be owned by an external atom or needs that feature's blank/default
+   * reset behavior. After resetting internal atoms, this also invokes feature
+   * reset hooks for mutable, transient table-instance data.
+   */
+  reset: () => void;
+  /**
+   * Updates the table options by applying a value or updater to the current
+   * resolved options and then merging them through `options.mergeOptions`.
+   */
+  setOptions: (newOptions: Updater<TableOptions<TFeatures, TData>>) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/Table.d.ts
+//#region src/types/Table.d.ts
+/**
+ * The core table object that only includes the core table functionality such as column, header, row, and table APIS.
+ * No features are included.
+ */
+interface Table_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends Table_Table<TFeatures, TData>, Table_Columns<TFeatures, TData>, Table_Rows<TFeatures, TData>, Table_RowModels<TFeatures, TData>, Table_Headers<TFeatures, TData> {}
+interface Table_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  cellSelectionFeature: Table_CellSelection<TFeatures, TData>;
+  cellSpanningFeature: Table_CellSpanning<TFeatures, TData>;
+  columnFacetingFeature: Table_ColumnFaceting<TFeatures, TData>;
+  columnFilteringFeature: Table_ColumnFiltering;
+  columnGroupingFeature: Table_ColumnGrouping<TFeatures, TData>;
+  columnOrderingFeature: Table_ColumnOrdering<TFeatures, TData>;
+  columnPinningFeature: Table_ColumnPinning<TFeatures, TData>;
+  columnResizingFeature: Table_ColumnResizing;
+  columnSizingFeature: Table_ColumnSizing;
+  columnVisibilityFeature: Table_ColumnVisibility<TFeatures, TData>;
+  globalFilteringFeature: Table_GlobalFiltering<TFeatures, TData>;
+  rowExpandingFeature: Table_RowExpanding<TFeatures, TData>;
+  rowPaginationFeature: Table_RowPagination<TFeatures, TData>;
+  rowPinningFeature: Table_RowPinning<TFeatures, TData>;
+  rowSelectionFeature: Table_RowSelection<TFeatures, TData>;
+  rowSortingFeature: Table_RowSorting<TFeatures, TData>;
+}
+/**
+ * The table object that includes both the core table functionality and the features that are enabled via the `features` table option.
+ */
+type Table<TFeatures extends TableFeatures, TData extends RowData$2> = Table_Core<TFeatures, TData> & ExtractFeatureMapTypes<TFeatures, Table_FeatureMap<TFeatures, TData>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/cells/coreCellsFeature.types.d.ts
+//#region src/core/cells/coreCellsFeature.types.d.ts
+interface CellContext<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  cell: Cell<TFeatures, TData, TValue>;
+  column: Column$2<TFeatures, TData, TValue>;
+  getValue: Getter<TValue>;
+  renderValue: Getter<TValue | null>;
+  row: Row<TFeatures, TData>;
+  table: Table<TFeatures, TData>;
+}
+interface Cell_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * The associated Column object for the cell.
+   */
+  column: Column$2<TFeatures, TData, TValue>;
+  /**
+   * The unique ID for the cell across the entire table.
+   */
+  id: string;
+  /**
+   * The associated Row object for the cell.
+   */
+  row: Row<TFeatures, TData>;
+  /**
+   * Reference to the parent table instance.
+   */
+  table: Table<TFeatures, TData>;
+}
+interface Cell_Cell<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> extends Cell_CoreProperties<TFeatures, TData, TValue> {
+  /**
+   * Returns the rendering context (or props) for cell-based components like cells and aggregated cells. Use these props with your framework's `flexRender` utility to render these using the template of your choice:
+   */
+  getContext: () => CellContext<TFeatures, TData, TValue>;
+  /**
+   * Returns the value for the cell, accessed via the associated column's accessor key or accessor function.
+   */
+  getValue: CellContext<TFeatures, TData, TValue>['getValue'];
+  /**
+   * Renders the value for a cell the same as `getValue`, but will return the `renderFallbackValue` if no value is found.
+   */
+  renderValue: CellContext<TFeatures, TData, TValue>['renderValue'];
+}
+interface TableOptions_Cell {
+  /**
+   * Value used when the desired value is not found in the data.
+   */
+  renderFallbackValue?: any;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/Cell.d.ts
+//#region src/types/Cell.d.ts
+interface Cell_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> extends Cell_Cell<TFeatures, TData, TValue> {}
+interface Cell_FeatureMap {
+  cellSelectionFeature: Cell_CellSelection;
+  cellSpanningFeature: Cell_CellSpanning;
+  columnGroupingFeature: Cell_ColumnGrouping;
+  rowAggregationFeature: Cell_RowAggregation;
+}
+type Cell<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = Cell_Core<TFeatures, TData, TValue> & ExtractFeatureMapTypes<TFeatures, Cell_FeatureMap>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/cell-selection/cellSelectionFeature.types.d.ts
+//#region src/features/cell-selection/cellSelectionFeature.types.d.ts
+/**
+ * A single rectangular cell selection, stored as its two defining corners.
+ *
+ * The `anchor` corner stays put while the `focus` corner moves during a
+ * shift-extend or a drag, so the pair carries strictly more information than a
+ * normalized min/max rectangle would. Corners are stored as flat row and column
+ * ids rather than nested objects or a packed `rowId_columnId` key, because
+ * `getRowId` is user-supplied and may return ids containing any separator.
+ */
+interface CellSelectionRange {
+  anchorColumnId: string;
+  anchorRowId: string;
+  focusColumnId: string;
+  focusRowId: string;
+  /**
+   * How this range changes the selection produced by the ranges before it.
+   * Defaults to `include`.
+   */
+  operation?: CellSelectionRangeOperation;
+}
+type CellSelectionRangeOperation = 'include' | 'exclude';
+/**
+ * Ordered range operations that produce the final selection. The last entry is
+ * the active operation that shift-extend and drag operate on.
+ *
+ * A bare array, matching `SortingState` and `ColumnFiltersState`. Drag session
+ * state deliberately lives outside this slice as non-reactive instance data, so
+ * nothing here is transient and the whole slice is safe to persist.
+ */
+type CellSelectionState = Array<CellSelectionRange>;
+interface TableState_CellSelection {
+  cellSelection: CellSelectionState;
+}
+/**
+ * A range resolved into inclusive display-order indexes.
+ *
+ * Ranges whose corners no longer resolve are omitted rather than clamped, so a
+ * range with a filtered-out corner contributes nothing while remaining in state.
+ */
+interface CellSelectionBounds {
+  maxColumnIndex: number;
+  maxRowIndex: number;
+  minColumnIndex: number;
+  minRowIndex: number;
+}
+/**
+ * Which sides of a selected cell sit on the outer boundary of the selection.
+ */
+interface CellSelectionEdges {
+  bottom: boolean;
+  left: boolean;
+  right: boolean;
+  top: boolean;
+}
+type CellSelectionDirection = 'up' | 'down' | 'left' | 'right';
+type CellSelectionRangeMode = 'replace' | 'include' | 'exclude';
+interface SelectCellRangeOptions {
+  /**
+   * Whether to replace the selection, add the range, or subtract the range.
+   * Defaults to `replace`.
+   */
+  mode?: CellSelectionRangeMode;
+  /**
+   * Whether the range should be added alongside existing ranges rather than
+   * replacing them. Defaults to `false`.
+   *
+   * @deprecated Use `mode: 'include'` instead.
+   */
+  additive?: boolean;
+}
+interface TableOptions_CellSelection<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Resets cell selection to `initialState.cellSelection` whenever `data`
+   * changes. Defaults to `true`.
+   *
+   * Ranges are stored as row and column ids, so new data would otherwise leave
+   * a selection pointing at rows that no longer exist, or silently re-select
+   * cells if the new data happens to reuse ids. Set to `false` to keep ranges
+   * across data changes, and note `autoResetAll` overrides this.
+   */
+  autoResetCellSelection?: boolean;
+  /**
+   * Enables inclusive cell range selection through shift-click and drag.
+   * Defaults to `true`.
+   */
+  enableCellRangeSelection?: boolean;
+  /**
+   * Allows cells to be selected.
+   *
+   * Provide a predicate to decide per cell. A column def may also opt out with
+   * its own `enableCellSelection: false`. Defaults to `true`.
+   */
+  enableCellSelection?: boolean | ((cell: Cell<TFeatures, TData, any>) => boolean);
+  /**
+   * Enables extending a selection by dragging across cells. Defaults to `true`.
+   */
+  enableCellSelectionDrag?: boolean;
+  /**
+   * Allows modifier interactions to add or subtract ranges. Defaults to `true`.
+   */
+  enableMultiCellRangeSelection?: boolean;
+  /**
+   * Determines whether a selection-start event should extend the active range
+   * instead of replacing the selection.
+   *
+   * By default, events with `shiftKey` directly on the event or on
+   * `event.nativeEvent` are treated as range-selection events.
+   */
+  isCellRangeSelectionEvent?: (event: unknown) => boolean;
+  /**
+   * Determines whether a selection-start event should add or subtract a new
+   * rectangle. The operation depends on whether the starting cell is selected.
+   *
+   * By default, events with `ctrlKey` or `metaKey` directly on the event or on
+   * `event.nativeEvent` are treated as multi-range events.
+   */
+  isMultiCellRangeSelectionEvent?: (event: unknown) => boolean;
+  /**
+   * Called with an updater when cell selection state changes. Pair this with
+   * `state.cellSelection` when using external state; external atoms can own the
+   * slice without this callback.
+   *
+   * A drag emits one change per cell crossed. Subscribe to
+   * `table.atoms.cellSelection` for finer-grained reads when that matters.
+   */
+  onCellSelectionChange?: OnChangeFn<CellSelectionState>;
+}
+interface ColumnDef_CellSelection {
+  /**
+   * Allows cells in this column to be selected. Defaults to `true`.
+   */
+  enableCellSelection?: boolean;
+}
+interface Cell_CellSelection {
+  /**
+   * Checks whether this cell can currently be selected.
+   */
+  getCanSelect: () => boolean;
+  /**
+   * Checks whether this cell is the active cell, i.e. the anchor of the most
+   * recent range.
+   */
+  getIsFocused: () => boolean;
+  /**
+   * Checks whether this cell falls inside the final positive selection.
+   */
+  getIsSelected: () => boolean;
+  /**
+   * Returns which sides of this cell sit on the outer boundary of the
+   * selection, for rendering a spreadsheet-style outline without each cell
+   * inspecting its neighbours.
+   *
+   * All sides are `false` when the cell is not selected.
+   */
+  getSelectionEdges: () => CellSelectionEdges;
+  /**
+   * Creates a handler that extends the active range to this cell while a drag
+   * is in progress. Bind it to `mouseenter`.
+   *
+   * The handler no-ops unless a drag is open, and skips redundant writes when
+   * the active range already focuses this cell.
+   */
+  getSelectionExtendHandler: () => (event: unknown) => void;
+  /**
+   * Creates a handler that begins a selection at this cell. Bind it to
+   * `mousedown`.
+   *
+   * Pass the original mouse event, or a framework event whose `nativeEvent` is
+   * that event, so modifier keys can be detected. The handler attaches its own
+   * document-level `mouseup` listener so a drag released outside the table
+   * still ends correctly; pass `contextDocument` when the table renders into
+   * another document, such as an iframe or popout window.
+   */
+  getSelectionStartHandler: (contextDocument?: Document) => (event: unknown) => void;
+  /**
+   * Returns `0` for the focused cell and `-1` otherwise, for roving tabindex.
+   */
+  getTabIndex: () => number;
+}
+interface Table_CellSelection<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Whether a drag selection is currently open.
+   *
+   * Non-reactive instance data rather than state: only the mouse handlers read
+   * it, nothing renders from it, and keeping it out of the slice means a
+   * selection persisted mid-drag cannot rehydrate into a stuck drag.
+   *
+   * @internal
+   */
+  _isSelectingCells: boolean;
+  /**
+   * Schedules a cell selection reset after `data` changes.
+   *
+   * Honors `autoResetAll` and `autoResetCellSelection`. Called by the core row
+   * model; you rarely need to invoke it yourself.
+   */
+  autoResetCellSelection: () => void;
+  /**
+   * Extends the active range one step in a direction, keeping its anchor fixed.
+   */
+  extendCellSelection: (direction: CellSelectionDirection) => void;
+  /**
+   * Returns the final positive selection as disjoint, inclusive display-order
+   * index rectangles after all include and exclude operations are applied.
+   *
+   * This is the memoized cache every per-cell read goes through. Ranges whose
+   * corners no longer resolve are omitted.
+   */
+  getCellSelectionBounds: () => Array<CellSelectionBounds>;
+  /**
+   * Returns the merged-cell rectangles of the rendered rows in selection's
+   * display-order index space, or an empty array when `cellSpanningFeature`
+   * is not registered.
+   *
+   * Selection rectangles expand to fully enclose these, so a merged cell is
+   * always entirely selected or entirely unselected.
+   */
+  getCellSelectionMergeBounds: () => Array<CellSelectionBounds>;
+  /**
+   * Returns the ids of all columns intersected by the selection.
+   */
+  getCellSelectionColumnIds: () => Array<string>;
+  /**
+   * Returns a column id to display-index map for the current column order.
+   *
+   * Registered so the lookup stays memoized even when `columnOrderingFeature`
+   * is absent, since its `getColumnIndexes` static rebuilds on every call.
+   *
+   * @internal
+   */
+  getCellSelectionColumnIndexes: () => Record<string, number>;
+  /**
+   * Returns the ids of all rows intersected by the selection.
+   */
+  getCellSelectionRowIds: () => Array<string>;
+  /**
+   * Returns the active cell, i.e. the anchor of the most recent operation.
+   * An exclusion's active cell is focused even though it is not selected.
+   */
+  getFocusedCell: () => Cell<TFeatures, TData, any> | undefined;
+  /**
+   * Returns the number of selected cells.
+   *
+   * Computed with rectangle arithmetic unless a per-cell
+   * `enableCellSelection` predicate requires enumeration.
+   */
+  getSelectedCellCount: () => number;
+  /**
+   * Returns the unique ids of all selected cells, in row-major order.
+   *
+   * This expands the selection, so it costs one pass over the selected area.
+   * It is memoized and never runs unless called.
+   */
+  getSelectedCellIds: () => Array<string>;
+  /**
+   * Returns each final positive selection region's values as a row-major grid.
+   *
+   * Indexed as `[regionIndex][rowIndex][columnIndex]`. Serializing this to
+   * clipboard text is left to userland, since the delimiter, the null
+   * representation, and any quoting rules are application decisions.
+   */
+  getSelectedCellRangesData: () => Array<Array<Array<unknown>>>;
+  /**
+   * Moves the selection one step in a direction, collapsing it to a single
+   * cell. Columns that cannot be selected are skipped over.
+   */
+  moveCellSelection: (direction: CellSelectionDirection) => void;
+  /**
+   * Resets `cellSelection` to `initialState.cellSelection`.
+   *
+   * Pass `true` to ignore initial state and reset to an empty selection.
+   */
+  resetCellSelection: (defaultState?: boolean) => void;
+  /**
+   * Selects every selectable cell in the table as one range.
+   */
+  selectAllCells: () => void;
+  /**
+   * Selects a rectangle using the requested replace/include/exclude mode.
+   */
+  selectCellRange: (range: CellSelectionRange, opts?: SelectCellRangeOptions) => void;
+  /**
+   * Updates cell selection state with a next value or updater function.
+   */
+  setCellSelection: (updater: Updater<CellSelectionState>) => void;
+  /**
+   * Collapses the selection to a single cell at the given coordinates.
+   */
+  setFocusedCell: (rowId: string, columnId: string) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/ColumnDef.d.ts
+//#region src/types/ColumnDef.d.ts
+interface ColumnMeta<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {}
+/**
+ * Resolves the type of `columnDef.meta` for a feature set.
+ *
+ * When the features object declares a `columnMeta` type-only slot
+ * (`tableFeatures({ ..., columnMeta: {} as MyColumnMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `ColumnMeta`
+ * interface.
+ */
+type ExtractColumnMeta<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = IsAny<TFeatures> extends true ? ColumnMeta<TFeatures, TData, TValue> : TFeatures extends {
+  columnMeta: infer TMeta extends object;
+} ? TMeta : ColumnMeta<TFeatures, TData, TValue>;
+/**
+ * Reads a cell value from an original row object.
+ *
+ * The row index is provided for accessors that need stable position-aware
+ * derived values.
+ */
+type AccessorFn<TData extends RowData$2, TValue extends CellData = CellData> = (originalRow: TData, index: number) => TValue;
+/**
+ * A renderable column template value.
+ *
+ * Strings render directly; functions receive the relevant cell/header context
+ * and can return framework-specific render output.
+ */
+type ColumnDefTemplate<TProps extends object> = string | ((props: TProps) => any);
+type StringOrTemplateHeader<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = string | ColumnDefTemplate<HeaderContext<TFeatures, TData, TValue>>;
+interface StringHeaderIdentifier {
+  /**
+   * Header text used both for rendering and as a fallback column id.
+   */
+  header: string;
+  /**
+   * Optional explicit id that overrides the header-derived id.
+   */
+  id?: string;
+}
+interface IdIdentifier<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * Explicit stable column id.
+   */
+  id: string;
+  /**
+   * Header text or template used to render this column's header.
+   */
+  header?: StringOrTemplateHeader<TFeatures, TData, TValue>;
+}
+type ColumnIdentifiers<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = IdIdentifier<TFeatures, TData, TValue> | StringHeaderIdentifier;
+interface ColumnDefBase_Core<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * Produces the values used by faceting/grouping for this column.
+   *
+   * When omitted, the normal accessor value is wrapped in a single-item array.
+   */
+  getUniqueValues?: AccessorFn<TData, ReadonlyArray<unknown>>;
+  /**
+   * Footer template rendered with header context.
+   */
+  footer?: ColumnDefTemplate<HeaderContext<TFeatures, TData, TValue>>;
+  /**
+   * Cell template rendered with cell context.
+   */
+  cell?: ColumnDefTemplate<CellContext<TFeatures, TData, TValue>>;
+  /**
+   * User-defined metadata available on the resolved column definition.
+   *
+   * Declare its type per-table via the `columnMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `ColumnMeta`.
+   */
+  meta?: ExtractColumnMeta<TFeatures, TData, TValue>;
+}
+interface ColumnDef_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData> {
+  cellSelectionFeature: ColumnDef_CellSelection;
+  cellSpanningFeature: ColumnDef_CellSpanning<TFeatures, TData, TValue>;
+  columnFilteringFeature: ColumnDef_ColumnFiltering<TFeatures, TData>;
+  columnGroupingFeature: ColumnDef_ColumnGrouping<TFeatures, TData>;
+  columnPinningFeature: ColumnDef_ColumnPinning;
+  columnResizingFeature: ColumnDef_ColumnResizing;
+  columnSizingFeature: ColumnDef_ColumnSizing;
+  columnVisibilityFeature: ColumnDef_ColumnVisibility;
+  globalFilteringFeature: ColumnDef_GlobalFiltering;
+  rowAggregationFeature: ColumnDef_RowAggregation<TFeatures, TData, TValue>;
+  rowSortingFeature: ColumnDef_RowSorting<TFeatures, TData>;
+}
+type ColumnDefBase<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase_Core<TFeatures, TData, TValue> & ExtractFeatureMapTypes<TFeatures, ColumnDef_FeatureMap<TFeatures, TData, TValue>>;
+type ColumnDefBase_All<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase_Core<TFeatures, TData, TValue> & Partial<ColumnDef_RowAggregation<TFeatures, TData, TValue> & ColumnDef_CellSelection & ColumnDef_CellSpanning<TFeatures, TData, TValue> & ColumnDef_ColumnVisibility & ColumnDef_ColumnPinning & ColumnDef_ColumnFiltering<TFeatures, TData> & ColumnDef_GlobalFiltering & ColumnDef_RowSorting<TFeatures, TData> & ColumnDef_ColumnGrouping<TFeatures, TData> & ColumnDef_ColumnSizing & ColumnDef_ColumnResizing>;
+type DisplayColumnDef<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase<TFeatures, TData, TValue> & ColumnIdentifiers<TFeatures, TData, TValue>;
+type GroupColumnDefBase<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase<TFeatures, TData, TValue> & {
+  columns?: ReadonlyArray<ColumnDef$2<TFeatures, TData, unknown>>;
+};
+type GroupColumnDef<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = GroupColumnDefBase<TFeatures, TData, TValue> & ColumnIdentifiers<TFeatures, TData, TValue>;
+type AccessorFnColumnDefBase<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase<TFeatures, TData, TValue> & {
+  accessorFn: AccessorFn<TData, TValue>;
+};
+type AccessorFnColumnDef<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = AccessorFnColumnDefBase<TFeatures, TData, TValue> & ColumnIdentifiers<TFeatures, TData, TValue>;
+type AccessorKeyColumnDefBase<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = ColumnDefBase<TFeatures, TData, TValue> & {
+  id?: string;
+  accessorKey: (string & {}) | keyof TData;
+};
+type AccessorKeyColumnDef<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = AccessorKeyColumnDefBase<TFeatures, TData, TValue> & Partial<ColumnIdentifiers<TFeatures, TData, TValue>>;
+type AccessorColumnDef<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = AccessorKeyColumnDef<TFeatures, TData, TValue> | AccessorFnColumnDef<TFeatures, TData, TValue>;
+type ColumnDef$2<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> = DisplayColumnDef<TFeatures, TData, TValue> | GroupColumnDef<TFeatures, TData, TValue> | AccessorColumnDef<TFeatures, TData, TValue>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-aggregation/rowAggregationFeature.types.d.ts
+//#region src/features/row-aggregation/rowAggregationFeature.types.d.ts
+/** Declaration-merging fallback for named aggregation definitions. */
+interface AggregationFns {}
+/** Values and table objects available while one aggregation is evaluated. */
+interface AggregationContext<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown> {
+  /** The column whose values are being aggregated. */
+  column: Column$2<TFeatures, TData, TValue>;
+  /** Convenience alias for `column.id`. */
+  columnId: string;
+  /** Maximum relative sub-row depth used to select `rows`. */
+  maxDepth: number;
+  /**
+   * Immediate sub-rows for grouped aggregation. This property is omitted
+   * for root or caller-supplied-row aggregation. At a terminal grouping level
+   * these are the direct data rows; at a nested level they are sub-row groups.
+   */
+  subRows?: ReadonlyArray<Row<TFeatures, TData>>;
+  /** Reads this column's value from one of `rows`. */
+  getValue: (row: Row<TFeatures, TData>) => TValue;
+  /**
+   * The synthetic grouped row receiving this result. This property is omitted
+   * for root or caller-supplied-row aggregation. Its `depth` identifies the
+   * grouping level when grouped aggregation needs that distinction.
+   */
+  groupingRow?: Row<TFeatures, TData>;
+  /**
+   * Unique rows selected at `maxDepth`. Branches that end before `maxDepth`
+   * contribute their deepest available row.
+   */
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column and rows. */
+  table: Table<TFeatures, TData>;
+}
+/** Additional values available when merging nested grouped results. */
+interface AggregationMergeContext<TFeatures extends TableFeatures, TData extends RowData$2, TValue, TResult> extends AggregationContext<TFeatures, TData, TValue> {
+  /** Results produced for each immediate sub-row group, in sub-row order. */
+  subRowResults: ReadonlyArray<TResult>;
+  /** Immediate sub-row groups corresponding to `subRowResults`. */
+  subRows: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/** A context-based aggregation definition and optional grouped-result merge. */
+interface AggregationFnDef<TFeatures extends TableFeatures = any, TData extends RowData$2 = any, TValue = unknown, TResult = unknown> {
+  /** Computes a result directly from the selected `rows`. */
+  aggregate: (context: AggregationContext<TFeatures, TData, TValue>) => TResult;
+  /**
+   * Combines already-computed immediate sub-row results. When omitted,
+   * nested grouping falls back to `aggregate` over the group's selected rows.
+   */
+  merge?: (context: AggregationMergeContext<TFeatures, TData, TValue, TResult>) => TResult;
+}
+/** Aggregation-definition registry carried by a table feature set. */
+interface RowModelFns_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  aggregationFns: Record<string, AggregationFnDef<TFeatures, TData, any, any>>;
+}
+/** String names available from a feature set's aggregation registry. */
+type ExtractAggregationFnKeys<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? keyof AggregationFns | BuiltInAggregationFn : TFeatures extends {
+  aggregationFns: infer TAggregationFns extends object;
+} ? Extract<keyof TAggregationFns, string> : keyof AggregationFns;
+/** A registered name, automatic inference, or inline aggregation definition. */
+type AggregationFnRef<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown, TResult = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDef<TFeatures, TData, TValue, TResult>;
+/** Gives an aggregation reference a stable key in a multiple result. */
+interface AggregationFnDescriptor<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown, TResult = unknown> {
+  /** The named, automatic, or inline definition to execute. */
+  aggregationFn: AggregationFnRef<TFeatures, TData, TValue, TResult>;
+  /** Stable key used in the object returned by a multiple aggregation. */
+  id: string;
+}
+/** One named or explicitly keyed entry in a multiple aggregation option. */
+type AggregationFnListItem<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDescriptor<TFeatures, TData, TValue, any>;
+/** A scalar aggregation reference or a list that produces a keyed object. */
+type AggregationFnOption<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown> = AggregationFnRef<TFeatures, TData, TValue, any> | ReadonlyArray<AggregationFnListItem<TFeatures, TData, TValue>>;
+/** Extracts the result type produced by an aggregation definition. */
+type AggregationResultOf<TDefinition> = TDefinition extends AggregationFnDef<any, any, any, infer TResult> ? TResult : unknown;
+type RegisteredAggregationResult<TFeatures extends TableFeatures> = TFeatures extends {
+  aggregationFns: infer TRegistry extends Record<string, unknown>;
+} ? AggregationResultOf<TRegistry[keyof TRegistry]> : unknown;
+/** Default public result union when a column's precise option is not known. */
+type ColumnAggregationValue<TFeatures extends TableFeatures> = RegisteredAggregationResult<TFeatures> | Record<string, RegisteredAggregationResult<TFeatures> | undefined> | undefined;
+/** A validated aggregation entry returned by `column.getAggregationFns()`. */
+interface ResolvedAggregationFn<TFeatures extends TableFeatures, TData extends RowData$2> {
+  /** Resolved definition, or `undefined` when configuration is invalid. */
+  aggregationFn: AggregationFnDef<TFeatures, TData, any, any> | undefined;
+  /** Key used for a multiple result; scalar inline definitions have no id. */
+  id: string | undefined;
+}
+/** Column-definition options installed by `rowAggregationFeature`. */
+interface ColumnDef_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /** Renderer used for a grouped row's aggregated cell. */
+  aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TFeatures, TData, TValue>['getContext']>>;
+  /**
+   * One aggregation reference for a scalar result, or an array for a keyed
+   * result object. Inline definitions in an array require an explicit `id`.
+   */
+  aggregationFn?: AggregationFnOption<TFeatures, TData, TValue>;
+  /**
+   * Maximum relative sub-row depth used for grouped aggregation and cached
+   * default totals. `0` selects the supplied root rows, `1` their direct
+   * sub-rows, and so on. Defaults to `0`.
+   */
+  maxAggregationDepth?: number;
+  /**
+   * Optionally supplies a precomputed aggregation value for this column.
+   * Return `{ value }` to handle the request, including `{ value: undefined }`;
+   * return `undefined` to use the local aggregation fallback.
+   */
+  getAggregationValue?: (context: AggregationValueContext<TFeatures, TData, TValue>) => AggregationValueResult | undefined;
+}
+/** Column instance APIs installed by `rowAggregationFeature`. */
+interface Column_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /** Resolves the configured scalar or multiple aggregation definitions. */
+  getAggregationFns: () => ReadonlyArray<ResolvedAggregationFn<TFeatures, TData>>;
+  /**
+   * Aggregates this column over the default pre-grouped row model, or over a
+   * caller-provided array of rows. `options.maxDepth` overrides the column's
+   * `maxAggregationDepth`. Explicit-row calls are intentionally not cached.
+   */
+  getAggregationValue: <TResult = ColumnAggregationValue<TFeatures>>(options?: AggregationValueOptions<TFeatures, TData>) => TResult;
+  /** Infers `sum` for a numeric first row and `extent` for a Date first row. */
+  getAutoAggregationFn: () => AggregationFnDef<TFeatures, TData, any, any> | undefined;
+}
+/** Options for a caller-requested column aggregation value. */
+interface AggregationValueOptions<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /** Overrides the column's `maxAggregationDepth` for this request. */
+  maxDepth?: number;
+  /** Rows to aggregate instead of the default pre-grouped row model. */
+  rows?: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/** Cell instance APIs installed by `rowAggregationFeature`. */
+interface Cell_RowAggregation {
+  /** Whether this cell displays an aggregate on a synthetic grouped row. */
+  getIsAggregated: () => boolean;
+}
+/** Internal per-row cache used while grouped aggregates are evaluated. */
+interface Row_RowAggregation {
+  /** Cached aggregate results keyed by column id; created lazily on grouped rows. */
+  _aggregationValuesCache?: Record<string, unknown>;
+}
+/** Values passed to a column-level aggregation-value provider. */
+interface AggregationValueContext<TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData> {
+  /** The column whose value was requested. */
+  column: Column$2<TFeatures, TData, TValue>;
+  /** Maximum relative sub-row depth used for the request. */
+  maxDepth: number;
+  /** Caller-provided rows, or `undefined` for the default row model. */
+  rows?: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column. */
+  table: Table<TFeatures, TData>;
+}
+/** Marks an aggregation-value override as handled. */
+interface AggregationValueResult<TResult = unknown> {
+  /** The supplied value. `undefined` is still a handled result. */
+  value: TResult;
+}
+/** Table options installed by `rowAggregationFeature`. */
+interface TableOptions_RowAggregation {
+  /**
+   * Disables local `column.getAggregationValue()` calculation when a column
+   * override does not handle the request. Group values supplied by manually
+   * grouped rows remain the responsibility of the data owner.
+   */
+  manualAggregation?: boolean;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/Column.d.ts
+//#region src/types/Column.d.ts
+interface Column_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue = unknown> extends Column_Column<TFeatures, TData, TValue> {}
+interface Column_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  rowAggregationFeature: Column_RowAggregation<TFeatures, TData>;
+  columnFacetingFeature: Column_ColumnFaceting<TFeatures, TData>;
+  columnFilteringFeature: Column_ColumnFiltering<TFeatures, TData>;
+  columnGroupingFeature: Column_ColumnGrouping;
+  columnOrderingFeature: Column_ColumnOrdering;
+  columnPinningFeature: Column_ColumnPinning;
+  columnResizingFeature: Column_ColumnResizing;
+  columnSizingFeature: Column_ColumnSizing;
+  columnVisibilityFeature: Column_ColumnVisibility;
+  globalFilteringFeature: Column_GlobalFiltering;
+  rowSortingFeature: Column_RowSorting<TFeatures, TData>;
+}
+type Column$2<TFeatures extends TableFeatures, TData extends RowData$2, TValue = unknown> = Column_Core<TFeatures, TData, TValue> & ExtractFeatureMapTypes<TFeatures, Column_FeatureMap<TFeatures, TData>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/headers/coreHeadersFeature.types.d.ts
+//#region src/core/headers/coreHeadersFeature.types.d.ts
+interface Table_Headers<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Builds the visible header groups for the current column tree, visibility,
+   * and pinning state.
+   */
+  getHeaderGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Builds footer groups by reversing the current header group order.
+   */
+  getFooterGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Flattens every header from every header group, including parent and
+   * placeholder headers.
+   */
+  getFlatHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Collects only leaf headers, excluding parent/group headers.
+   */
+  getLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+}
+interface HeaderContext<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * An instance of a column.
+   */
+  column: Column$2<TFeatures, TData, TValue>;
+  /**
+   * An instance of a header.
+   */
+  header: Header<TFeatures, TData, TValue>;
+  /**
+   * The table instance.
+   */
+  table: Table<TFeatures, TData>;
+}
+interface Header_CoreProperties<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  /**
+   * The col-span for the header.
+   */
+  colSpan: number;
+  /**
+   * The header's associated column object.
+   */
+  column: Column$2<TFeatures, TData, TValue>;
+  /**
+   * The depth of the header, zero-indexed.
+   */
+  depth: number;
+  /**
+   * The header's associated header group object.
+   */
+  headerGroup: HeaderGroup<TFeatures, TData> | null;
+  /**
+   * The unique identifier for the header.
+   */
+  id: string;
+  /**
+   * The index for the header within the header group.
+   */
+  index: number;
+  /**
+   * A boolean denoting if the header is a placeholder header. Placeholder
+   * headers fill the rows above a shallow leaf column's real header so that
+   * every header group row accounts for every visible column. Render them as
+   * empty cells, or use `header.rowSpan` to merge each chain of placeholders
+   * into one vertically spanning header cell.
+   */
+  isPlaceholder: boolean;
+  /**
+   * If the header is a placeholder header, this will be a unique header ID that does not conflict with any other headers across the table.
+   */
+  placeholderId?: string;
+  /**
+   * The number of header group rows the header should span when merging header
+   * cells vertically. A leaf column that is shallower than the deepest leaf
+   * column produces a chain of placeholder headers above its real header; the
+   * placeholder at the top of the chain reports the chain's full span, and
+   * every header it covers (including the real leaf header in the bottom row)
+   * reports 0. To merge vertically, skip headers with a rowSpan of 0 and
+   * render every other header with the `rowSpan` attribute and its column's
+   * header content, even when it is a placeholder. Headers in even column
+   * trees always report 1.
+   */
+  rowSpan: number;
+  /**
+   * The header's hierarchical sub/child headers. Will be empty if the header's associated column is a leaf-column.
+   */
+  subHeaders: Array<Header<TFeatures, TData, TValue>>;
+  /**
+   * Reference to the parent table instance.
+   */
+  table: Table<TFeatures, TData>;
+}
+interface Header_Header<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> extends Header_CoreProperties<TFeatures, TData, TValue> {
+  /**
+   * Returns the rendering context (or props) for column-based components like headers, footers and filters.
+   */
+  getContext: () => HeaderContext<TFeatures, TData, TValue>;
+  /**
+   * Returns the leaf headers hierarchically nested under this header.
+   */
+  getLeafHeaders: () => Array<Header<TFeatures, TData, TValue>>;
+}
+interface HeaderGroup_Header<in out TFeatures extends TableFeatures, in out TData extends RowData$2, TValue extends CellData = CellData> {
+  depth: number;
+  headers: Array<Header<TFeatures, TData, TValue>>;
+  id: string;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/HeaderGroup.d.ts
+//#region src/types/HeaderGroup.d.ts
+interface HeaderGroup_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends HeaderGroup_Header<TFeatures, TData> {}
+interface HeaderGroup<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends HeaderGroup_Core<TFeatures, TData> {}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-pinning/columnPinningFeature.types.d.ts
+//#region src/features/column-pinning/columnPinningFeature.types.d.ts
+/**
+ * Logical column pinning region.
+ *
+ * In LTR languages/layouts, `start` usually corresponds to left and `end`
+ * usually corresponds to right. In RTL languages/layouts, `start` usually
+ * corresponds to right and `end` usually corresponds to left.
+ */
+type ColumnPinningPosition = false | 'start' | 'end';
+interface ColumnPinningState {
+  start: Array<string>;
+  end: Array<string>;
+}
+interface TableState_ColumnPinning {
+  columnPinning: ColumnPinningState;
+}
+interface TableOptions_ColumnPinning {
+  /**
+   * Allows columns to be pinned into logical start and end regions.
+   *
+   * In LTR languages/layouts, start usually corresponds to left and end to
+   * right. In RTL languages/layouts, start usually corresponds to right and end
+   * to left.
+   *
+   * Defaults to `true`; column-level `enablePinning` can still opt individual
+   * columns out.
+   */
+  enableColumnPinning?: boolean;
+  /**
+   * Called with an updater when column pinning state changes. Pair this with
+   * `state.columnPinning` when using external state; external atoms can own the
+   * slice without this callback.
+   */
+  onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+}
+interface ColumnDef_ColumnPinning {
+  /**
+   * Allows this column's leaf columns to be pinned.
+   *
+   * Defaults to `true`; table-level `enableColumnPinning` must also allow
+   * pinning.
+   */
+  enablePinning?: boolean;
+}
+interface Column_ColumnPinning {
+  /**
+   * Checks whether this column or any of its leaves can be pinned.
+   */
+  getCanPin: () => boolean;
+  /**
+   * Reads the column's logical pinned position: `'start'`, `'end'`, or `false`.
+   */
+  getIsPinned: () => ColumnPinningPosition;
+  /**
+   * Finds this column's index within its pinned region.
+   */
+  getPinnedIndex: () => number;
+  /**
+   * Pins this column's leaf columns to logical start or end, or unpins them
+   * when `false` is passed.
+   */
+  pin: (position: ColumnPinningPosition) => void;
+}
+interface Row_ColumnPinning<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Gets visible row cells whose columns are not pinned start or end.
+   */
+  getCenterVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Gets visible row cells whose columns are pinned to logical start.
+   */
+  getStartVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+  /**
+   * Gets visible row cells whose columns are pinned to logical end.
+   */
+  getEndVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>;
+}
+interface Table_ColumnPinning<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Builds flat center-region headers for columns that are not pinned,
+   * including parent headers.
+   */
+  getCenterFlatHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Builds footer groups for the center region of unpinned columns.
+   */
+  getCenterFooterGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Builds header groups for the center region of unpinned columns.
+   */
+  getCenterHeaderGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Gets leaf columns that are not pinned start or end.
+   */
+  getCenterLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Builds center-region leaf headers for columns that are not pinned.
+   */
+  getCenterLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the unpinned center region.
+   */
+  getCenterVisibleLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Checks whether any columns are pinned, optionally limited to one side.
+   */
+  getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
+  /**
+   * Builds flat logical start-region headers for pinned columns, including parent
+   * headers.
+   */
+  getStartFlatHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Builds footer groups for logical start-pinned columns.
+   */
+  getStartFooterGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Builds header groups for logical start-pinned columns.
+   */
+  getStartHeaderGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Gets leaf columns pinned to the logical start region in pinning-state order.
+   */
+  getStartLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Builds leaf headers for logical start-pinned columns.
+   */
+  getStartLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the logical start pinned region.
+   */
+  getStartVisibleLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Builds flat logical end-region headers for pinned columns, including parent
+   * headers.
+   */
+  getEndFlatHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Builds footer groups for logical end-pinned columns.
+   */
+  getEndFooterGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Builds header groups for logical end-pinned columns.
+   */
+  getEndHeaderGroups: () => Array<HeaderGroup<TFeatures, TData>>;
+  /**
+   * Gets leaf columns pinned to the logical end region in pinning-state order.
+   */
+  getEndLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Builds leaf headers for logical end-pinned columns.
+   */
+  getEndLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns in the logical end pinned region.
+   */
+  getEndVisibleLeafColumns: () => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Resets `columnPinning` to `initialState.columnPinning`.
+   *
+   * Pass `true` to ignore initial state and reset to empty start/end arrays.
+   */
+  resetColumnPinning: (defaultState?: boolean) => void;
+  /**
+   * Updates column pinning state with a next state or updater function.
+   */
+  setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+  /**
+   * Returns pinned leaf columns for the requested pinning region.
+   */
+  getPinnedLeafColumns: (position: ColumnPinningPosition | 'center') => Array<Column$2<TFeatures, TData, unknown>>;
+  /**
+   * Lists visible leaf columns for the requested pinning region.
+   */
+  getPinnedVisibleLeafColumns: (position: ColumnPinningPosition | 'center') => Array<Column$2<TFeatures, TData, unknown>>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/Row.d.ts
+//#region src/types/Row.d.ts
+interface Row_Core<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends Row_Row<TFeatures, TData> {}
+interface Row_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  rowAggregationFeature: Row_RowAggregation;
+  columnFilteringFeature: Row_ColumnFiltering<TFeatures, TData>;
+  columnGroupingFeature: Row_ColumnGrouping;
+  columnPinningFeature: Row_ColumnPinning<TFeatures, TData>;
+  columnVisibilityFeature: Row_ColumnVisibility<TFeatures, TData>;
+  rowExpandingFeature: Row_RowExpanding;
+  rowPinningFeature: Row_RowPinning;
+  rowSelectionFeature: Row_RowSelection;
+}
+type Row<TFeatures extends TableFeatures, TData extends RowData$2> = Row_Core<TFeatures, TData> & ExtractFeatureMapTypes<TFeatures, Row_FeatureMap<TFeatures, TData>>;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-sorting/rowSortingFeature.types.d.ts
+//#region src/features/row-sorting/rowSortingFeature.types.d.ts
+type SortDirection = 'asc' | 'desc';
+interface ColumnSort {
+  desc: boolean;
+  id: string;
+}
+type SortingState = Array<ColumnSort>;
+interface TableState_RowSorting {
+  sorting: SortingState;
+}
+interface RowModelFns_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  sortFns: Record<string, SortFn<TFeatures, TData>>;
+}
+interface SortFns {}
+interface SortFn<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  (rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string): number;
+  /**
+   * Normalizes each row's value before the two sides are compared. Only
+   * honored by sorting functions built with `constructSortFn` (including all
+   * built-in sorting functions).
+   */
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The definition object accepted by `constructSortFn`.
+ *
+ * `sort` is a value-level comparator: it receives both rows' (resolved) data
+ * values instead of the whole rows, so normalization concerns stay in
+ * `resolveDataValue`.
+ */
+interface SortFnDef<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  sort: (dataValueA: any, dataValueB: any, rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+  resolveDataValue?: TransformDataValueFn;
+}
+/**
+ * The shape returned by `constructSortFn`: a `SortFn` with its definition
+ * attached, so variants can be built by spreading it into another
+ * `constructSortFn` call.
+ *
+ * The call signature is generic so a created sorting function can be used
+ * with any table's rows, regardless of the feature set it was defined
+ * against.
+ */
+interface CreatedSortFn<in out TFeatures extends TableFeatures, in out TData extends RowData$2> extends SortFnDef<TFeatures, TData> {
+  <TRowFeatures extends TableFeatures, TRowData extends RowData$2>(rowA: Row<TRowFeatures, TRowData>, rowB: Row<TRowFeatures, TRowData>, columnId: string): number;
+}
+/**
+ * Resolves the valid string names for `columnDef.sortFn` for a feature set.
+ *
+ * When the features object declares a `sortFns` registry
+ * (`tableFeatures({ ..., sortFns })`), its keys are the only valid names; a
+ * name is only assignable if a sorting function is actually registered for it.
+ * Otherwise this falls back to the global declaration-merged `SortFns`
+ * interface.
+ */
+type ExtractSortFnKeys<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? keyof SortFns | BuiltInSortFn : TFeatures extends {
+  sortFns: infer TSortFns extends object;
+} ? Extract<keyof TSortFns, string> : keyof SortFns;
+type SortFnOption<TFeatures extends TableFeatures, TData extends RowData$2> = 'auto' | ExtractSortFnKeys<TFeatures> | SortFn<TFeatures, TData>;
+interface ColumnDef_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Enables/Disables multi-sorting for this column.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for this column.
+   */
+  enableSorting?: boolean;
+  /**
+   * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, e.g. a ranking (1st, 2nd, 3rd) or golf-like scoring
+   */
+  invertSorting?: boolean;
+  /**
+   * Set to `true` for sorting toggles on this column to start in the descending direction.
+   */
+  sortDescFirst?: boolean;
+  /**
+   * The sorting function to use with this column.
+   * - A `string` referencing a built-in sorting function
+   * - A custom sorting function
+   */
+  sortFn?: SortFnOption<TFeatures, TData>;
+  /**
+   * The priority of undefined values when sorting this column.
+   * - `false`
+   *   - Undefined values will be passed to the sorting function like any other value with no special handling; the sorting function is responsible for handling them
+   * - `-1`
+   *   - Undefined values will be sorted with higher priority (ascending) (if ascending, undefined will appear on the beginning of the list)
+   * - `1`
+   *   - Undefined values will be sorted with lower priority (descending) (if ascending, undefined will appear on the end of the list)
+   * - `'first'`
+   *   - Undefined values will be pushed to the beginning of the list regardless of sort direction
+   * - `'last'`
+   *   - Undefined values will be pushed to the end of the list regardless of sort direction
+   */
+  sortUndefined?: false | -1 | 1 | 'first' | 'last';
+}
+interface Column_RowSorting<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Removes this column from the table's sorting state
+   */
+  clearSorting: () => void;
+  /**
+   * Returns a sort direction automatically inferred based on the columns values.
+   */
+  getAutoSortDir: () => SortDirection;
+  /**
+   * Returns a sorting function automatically inferred based on the columns values.
+   */
+  getAutoSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Returns whether this column can be multi-sorted.
+   */
+  getCanMultiSort: () => boolean;
+  /**
+   * Returns whether this column can be sorted.
+   */
+  getCanSort: () => boolean;
+  /**
+   * Returns the first direction that should be used when sorting this column.
+   */
+  getFirstSortDir: () => SortDirection;
+  /**
+   * Reads this column's current sort direction, or `false` when unsorted.
+   */
+  getIsSorted: () => false | SortDirection;
+  /**
+   * Returns the next sorting order. Pass `multi` to resolve the order for a
+   * multi-sort toggle, where `enableMultiRemove` governs whether the cycle can
+   * remove the sort.
+   */
+  getNextSortingOrder: (multi?: boolean) => SortDirection | false;
+  /**
+   * Finds this column's position in the ordered sorting state.
+   */
+  getSortIndex: () => number;
+  /**
+   * Returns the resolved sorting function to be used for this column
+   */
+  getSortFn: () => SortFn<TFeatures, TData>;
+  /**
+   * Creates a header/control handler that toggles this column's sorting state.
+   */
+  getToggleSortingHandler: () => undefined | ((event: unknown) => void);
+  /**
+   * Toggles this column's sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additively multi-sort the column (or toggle it if it is already sorted).
+   */
+  toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+}
+interface TableOptions_RowSorting {
+  /**
+   * Resets sorting to its initial state when the `data` option changes.
+   *
+   * This is disabled by default. `autoResetAll` overrides this option when it
+   * is explicitly set.
+   */
+  autoResetSorting?: boolean;
+  /**
+   * Allows multi-sort toggles to remove a column from sorting state.
+   */
+  enableMultiRemove?: boolean;
+  /**
+   * Enables/Disables multi-sorting for the table.
+   */
+  enableMultiSort?: boolean;
+  /**
+   * Enables/Disables sorting for the table.
+   */
+  enableSorting?: boolean;
+  /**
+   * Enables/Disables the ability to remove sorting for the table.
+   * - If `true` then changing sort order will cycle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...
+   * - If `false` then changing sort order will cycle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...
+   */
+  enableSortingRemoval?: boolean;
+  /**
+   * Pass a custom function that will be used to determine if a multi-sort event should be triggered. It is passed the event from the sort toggle handler and should return `true` if the event should trigger a multi-sort.
+   */
+  isMultiSortEvent?: (e: unknown) => boolean;
+  /**
+   * Enables manual sorting for the table. If this is `true`, you will be expected to sort your data before it is passed to the table. This is useful if you are doing server-side sorting.
+   */
+  manualSorting?: boolean;
+  /**
+   * Set a maximum number of columns that can be multi-sorted.
+   */
+  maxMultiSortColCount?: number;
+  /**
+   * Called with an updater when sorting state changes. Pair this with
+   * `state.sorting` when using external state; external atoms can own the slice
+   * without this callback.
+   */
+  onSortingChange?: OnChangeFn<SortingState>;
+  /**
+   * If `true`, all sorts will default to descending as their first toggle state.
+   */
+  sortDescFirst?: boolean;
+}
+interface Table_RowSorting<in out _TFeatures extends TableFeatures, in out _TData extends RowData$2> {
+  /**
+   * Resets `sorting` to `initialState.sorting`.
+   *
+   * Pass `true` to ignore initial state and reset to `[]`.
+   */
+  resetSorting: (defaultState?: boolean) => void;
+  /**
+   * Updates sorting state with a next ordered array or updater function.
+   */
+  setSorting: (updater: Updater<SortingState>) => void;
+}
+interface Table_RowModels_Sorted<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  /**
+   * Reads the row model immediately before sorting.
+   */
+  getPreSortedRowModel: () => RowModel<TFeatures, TData>;
+  /**
+   * Resolves the row model after sorting has been applied.
+   */
+  getSortedRowModel: () => RowModel<TFeatures, TData>;
+}
+interface CachedRowModel_Sorted<in out TFeatures extends TableFeatures, in out TData extends RowData$2> {
+  sortedRowModel: () => RowModel<TFeatures, TData>;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/cell-selection/cellSelectionFeature.d.ts
+//#region src/features/cell-selection/cellSelectionFeature.d.ts
+/**
+ * Feature that adds spreadsheet-style cell range selection state and APIs.
+ */
+declare const cellSelectionFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/cell-spanning/cellSpanningFeature.d.ts
+//#region src/features/cell-spanning/cellSpanningFeature.d.ts
+/**
+ * Feature that merges adjacent cells that share a value into row-spanning
+ * cells, and lets a column def declare column-spanning cells per row.
+ *
+ * Stateless: spans are always derived from the rows that are currently
+ * rendered, so there is nothing to persist and nothing to configure beyond the
+ * column defs.
+ */
+declare const cellSpanningFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-faceting/columnFacetingFeature.d.ts
+//#region src/features/column-faceting/columnFacetingFeature.d.ts
+/**
+ * Feature that derives faceted row models, unique values, and min/max values for filters.
+ *
+ * These APIs are deliberately not memoized at this layer: the stock
+ * `createFaceted*` factories memoize internally (like every other stock row
+ * model), and an extra memo layer here would freeze custom factories whose
+ * data changes independently of the faceted row model. Custom factories own
+ * their memoization.
+ */
+declare const columnFacetingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-aggregation/rowAggregationFeature.d.ts
+//#region src/features/row-aggregation/rowAggregationFeature.d.ts
+/**
+ * Independent aggregation feature for grouped values and root/custom-row totals.
+ */
+declare const rowAggregationFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-filtering/columnFilteringFeature.d.ts
+//#region src/features/column-filtering/columnFilteringFeature.d.ts
+/**
+ * Feature that adds per-column filtering state, options, and column/table filter APIs.
+ */
+declare const columnFilteringFeature$1: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-grouping/columnGroupingFeature.d.ts
+//#region src/features/column-grouping/columnGroupingFeature.d.ts
+/**
+ * Feature that adds column grouping state and grouped row APIs.
+ */
+declare const columnGroupingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-ordering/columnOrderingFeature.d.ts
+//#region src/features/column-ordering/columnOrderingFeature.d.ts
+/**
+ * Feature that adds column ordering state and APIs for ordering leaf columns.
+ */
+declare const columnOrderingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-pinning/columnPinningFeature.d.ts
+//#region src/features/column-pinning/columnPinningFeature.d.ts
+/**
+ * Feature that adds column pinning state and APIs for logical start, center,
+ * and end regions.
+ *
+ * In LTR languages/layouts, start usually corresponds to left and end to
+ * right. In RTL languages/layouts, start usually corresponds to right and end
+ * to left.
+ */
+declare const columnPinningFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-resizing/columnResizingFeature.d.ts
+//#region src/features/column-resizing/columnResizingFeature.d.ts
+/**
+ * Feature that adds column resizing state, options, and resize handlers.
+ */
+declare const columnResizingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-sizing/columnSizingFeature.d.ts
+//#region src/features/column-sizing/columnSizingFeature.d.ts
+/**
+ * Feature that adds column sizing state, defaults, and size measurement APIs.
+ */
+declare const columnSizingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/column-visibility/columnVisibilityFeature.d.ts
+//#region src/features/column-visibility/columnVisibilityFeature.d.ts
+/**
+ * Feature that adds column visibility state and APIs for hiding and showing columns.
+ */
+declare const columnVisibilityFeature$1: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/global-filtering/globalFilteringFeature.d.ts
+//#region src/features/global-filtering/globalFilteringFeature.d.ts
+/**
+ * Feature that adds global filtering state, defaults, and global filter APIs.
+ */
+declare const globalFilteringFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-expanding/rowExpandingFeature.d.ts
+//#region src/features/row-expanding/rowExpandingFeature.d.ts
+/**
+ * Feature that adds row expansion state and APIs for expandable row trees.
+ */
+declare const rowExpandingFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-pagination/rowPaginationFeature.d.ts
+//#region src/features/row-pagination/rowPaginationFeature.d.ts
+/**
+ * Feature that adds pagination state and table APIs for page navigation.
+ */
+declare const rowPaginationFeature$1: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-pinning/rowPinningFeature.d.ts
+//#region src/features/row-pinning/rowPinningFeature.d.ts
+/**
+ * Feature that adds row pinning state and APIs for top, center, and bottom rows.
+ */
+declare const rowPinningFeature: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-selection/rowSelectionFeature.d.ts
+//#region src/features/row-selection/rowSelectionFeature.d.ts
+/**
+ * Feature that adds row selection state and APIs for row and page selection.
+ */
+declare const rowSelectionFeature$1: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/row-sorting/rowSortingFeature.d.ts
+//#region src/features/row-sorting/rowSortingFeature.d.ts
+/**
+ * Feature that adds row sorting state, defaults, and column/table sorting APIs.
+ */
+declare const rowSortingFeature$1: TableFeature;
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/features/stockFeatures.d.ts
+//#region src/features/stockFeatures.d.ts
+interface StockFeatures {
+  cellSelectionFeature: typeof cellSelectionFeature;
+  cellSpanningFeature: typeof cellSpanningFeature;
+  columnFacetingFeature: typeof columnFacetingFeature;
+  columnFilteringFeature: typeof columnFilteringFeature$1;
+  columnGroupingFeature: typeof columnGroupingFeature;
+  columnOrderingFeature: typeof columnOrderingFeature;
+  columnPinningFeature: typeof columnPinningFeature;
+  columnResizingFeature: typeof columnResizingFeature;
+  columnSizingFeature: typeof columnSizingFeature;
+  columnVisibilityFeature: typeof columnVisibilityFeature$1;
+  globalFilteringFeature: typeof globalFilteringFeature;
+  rowAggregationFeature: typeof rowAggregationFeature;
+  rowExpandingFeature: typeof rowExpandingFeature;
+  rowPaginationFeature: typeof rowPaginationFeature$1;
+  rowPinningFeature: typeof rowPinningFeature;
+  rowSelectionFeature: typeof rowSelectionFeature$1;
+  rowSortingFeature: typeof rowSortingFeature$1;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/types/TableFeatures.d.ts
+//#region src/types/TableFeatures.d.ts
+/**
+ * Detects whether a type is `any`.
+ *
+ * Several feature-map helpers need a separate `any` path so broad generic
+ * usage still exposes all known feature APIs instead of narrowing to no keys.
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Converts a union to an intersection, returning `{}` for `never`.
+ *
+ * This keeps empty feature-map lookups usable as an intersection member.
+ */
+type UnionToIntersectionOrEmpty<T> = [T] extends [never] ? {} : UnionToIntersection<T> & {};
+/**
+ * Extracts the API/types contributed by the features present in `TFeatures`.
+ *
+ * `TFeatureMap` maps feature keys to the types they contribute. When
+ * `TFeatures` is `any`, all feature-map entries are included to preserve the
+ * permissive behavior expected by broad table types. Otherwise, only entries
+ * whose keys are present in `TFeatures` are intersected together.
+ */
+type ExtractFeatureMapTypes<TFeatures extends TableFeatures, TFeatureMap extends object> = IsAny<TFeatures> extends true ? UnionToIntersection<TFeatureMap[keyof TFeatureMap]> : UnionToIntersectionOrEmpty<TFeatureMap[Extract<keyof TFeatures, keyof TFeatureMap>]>;
+/**
+ * Declaration-merge target for custom table features.
+ *
+ * Add custom feature keys here so `TableFeatures` can accept them in the
+ * `features` option and use the same feature-map extraction system as built-in
+ * features.
+ */
+interface Plugins {}
+/**
+ * Keys of the `features` option that are not table features themselves.
+ *
+ * These slots carry per-table types (`tableMeta`, `columnMeta`), row model
+ * factories, and row model function registries. They are stripped from the
+ * table's registered `_features` at runtime and excluded from feature-derived
+ * options such as the generated `debug*` keys.
+ */
+type NonFeatureKeys = 'aggregationFns' | 'columnMeta' | 'coreRowModel' | 'expandedRowModel' | 'facetedMinMaxValues' | 'facetedRowModel' | 'facetedUniqueValues' | 'filterFns' | 'filterMeta' | 'filteredRowModel' | 'groupedRowModel' | 'paginatedRowModel' | 'sortFns' | 'sortedRowModel' | 'tableMeta';
+/**
+ * Maps each row model and fn registry slot to the feature(s) that must be
+ * registered alongside it in the same features object.
+ *
+ * Custom features can declaration-merge their own slot prerequisites into this
+ * interface to get the same validation from `tableFeatures()`.
+ */
+interface FeatureSlotPrereqs {
+  /**
+   * Named aggregation functions require the independent aggregation feature.
+   */
+  aggregationFns: 'rowAggregationFeature';
+  /**
+   * Column resizing builds on the column sizing state and APIs.
+   */
+  columnResizingFeature: 'columnSizingFeature';
+  /**
+   * Expanded row-model factories require row expanding APIs and state.
+   */
+  expandedRowModel: 'rowExpandingFeature';
+  /**
+   * Faceted min/max factories require column faceting APIs.
+   */
+  facetedMinMaxValues: 'columnFacetingFeature';
+  /**
+   * Faceted row-model factories require column faceting APIs.
+   */
+  facetedRowModel: 'columnFacetingFeature';
+  /**
+   * Faceted unique-value factories require column faceting APIs.
+   */
+  facetedUniqueValues: 'columnFacetingFeature';
+  /**
+   * Filtered row-model factories require column filtering APIs and state.
+   */
+  filteredRowModel: 'columnFilteringFeature';
+  /**
+   * Named filter functions are only meaningful when column filtering is enabled.
+   */
+  filterFns: 'columnFilteringFeature';
+  /**
+   * Filter metadata types are only read and written by filtering features.
+   */
+  filterMeta: 'columnFilteringFeature';
+  /**
+   * Global filtering builds on column filtering state and filter functions.
+   */
+  globalFilteringFeature: 'columnFilteringFeature';
+  /**
+   * Grouped row-model factories require column grouping APIs and state.
+   */
+  groupedRowModel: 'columnGroupingFeature';
+  /**
+   * Paginated row-model factories require row pagination APIs and state.
+   */
+  paginatedRowModel: 'rowPaginationFeature';
+  /**
+   * Sorted row-model factories require row sorting APIs and state.
+   */
+  sortedRowModel: 'rowSortingFeature';
+  /**
+   * Named sorting functions are only meaningful when row sorting is enabled.
+   */
+  sortFns: 'rowSortingFeature';
+}
+/**
+ * Validates that every row model and fn registry slot in a features object is
+ * accompanied by its prerequisite feature.
+ *
+ * Slots whose prerequisite is missing have their type replaced with a literal
+ * error message, so the offending property fails to type-check with a message
+ * naming the feature that needs to be added.
+ */
+type ValidateFeatureSlots<TFeatures extends TableFeatures> = IsAny<TFeatures> extends true ? {} : { [K in keyof TFeatures as K extends keyof FeatureSlotPrereqs ? K : never]: K extends keyof FeatureSlotPrereqs ? [Extract<FeatureSlotPrereqs[K], keyof TFeatures>] extends [never] ? `Error: '${K & string}' requires '${FeatureSlotPrereqs[K] & string}' to be included in this table's features.` : TFeatures[K] : never; };
+/**
+ * Complete feature registry for a table.
+ *
+ * This type combines core features, stock features, declaration-merged custom
+ * plugins, row-model factory slots, function registries, and type-only meta
+ * slots. The concrete `features` object passed to `tableFeatures()` determines
+ * which feature APIs are included throughout table, row, column, cell, header,
+ * options, and state types.
+ */
+interface TableFeatures extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {
+  /**
+   * Registry of aggregation functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `aggregationFn` on
+   * column definitions, with full inference. Import the built-in aggregation
+   * functions you use individually and register them by their conventional
+   * names: `aggregationFns: { sum: aggregationFn_sum, myCustomAggregationFn }`.
+   * Spreading the exported `aggregationFns` registry also works, but puts
+   * every built-in aggregation function in your bundle.
+   */
+  aggregationFns?: Record<string, AggregationFnDef<any, any, any, any>>;
+  /**
+   * Type-only slot for declaring the type of `columnDef.meta` for all columns
+   * of this table.
+   *
+   * Pass a phantom value: `columnMeta: {} as MyColumnMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `ColumnMeta` interface applies.
+   */
+  columnMeta?: object;
+  /**
+   * Factory for the table's core (unmodified) row model. Defaults to the
+   * built-in `createCoreRowModel()` when omitted.
+   */
+  coreRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Factory for the client-side expanded row model. Pass the exported
+   * `createExpandedRowModel()` or implement your own. Not needed for
+   * server-side expansion.
+   */
+  expandedRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Factory for per-column faceted min/max values. Pass the exported
+   * `createFacetedMinMaxValues()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedMinMaxValues?: (table: any, columnId: string) => () => [number, number] | undefined;
+  /**
+   * Factory for the per-column faceted row model. Pass the exported
+   * `createFacetedRowModel()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedRowModel?: (table: any, columnId: string) => () => RowModel<any, any>;
+  /**
+   * Factory for per-column faceted unique values. Pass the exported
+   * `createFacetedUniqueValues()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedUniqueValues?: (table: any, columnId: string) => () => Map<any, number>;
+  /**
+   * Factory for the client-side filtered row model. Pass the exported
+   * `createFilteredRowModel()` or implement your own. Not needed for
+   * server-side filtering.
+   */
+  filteredRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Registry of filter functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `filterFn` on
+   * column definitions and the `globalFilterFn` option, with full inference.
+   * Import the built-in filter functions you use individually and register
+   * them by their conventional names:
+   * `filterFns: { includesString: filterFn_includesString, myCustomFilterFn }`.
+   * Spreading the exported `filterFns` registry also works, but puts every
+   * built-in filter function in your bundle.
+   */
+  filterFns?: Record<string, FilterFn<any, any>>;
+  /**
+   * Type-only slot for declaring the type of the filter meta that filter
+   * functions attach to rows via `addMeta` and that is read back from
+   * `row.columnFiltersMeta`.
+   *
+   * Pass a phantom value: `filterMeta: {} as MyFilterMeta` (or
+   * `metaHelper<MyFilterMeta>()`). The value itself is ignored and stripped
+   * from the table's registered features at runtime; only its type is used.
+   *
+   * When omitted, the global declaration-merged `FilterMeta` interface applies.
+   */
+  filterMeta?: object;
+  /**
+   * Factory for the client-side grouped row model. Pass the exported
+   * `createGroupedRowModel()` or implement your own. Not needed for
+   * server-side grouping.
+   */
+  groupedRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Factory for the client-side paginated row model. Pass the exported
+   * `createPaginatedRowModel()` or implement your own. Not needed for
+   * server-side pagination.
+   */
+  paginatedRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Factory for the client-side sorted row model. Pass the exported
+   * `createSortedRowModel()` or implement your own. Not needed for
+   * server-side sorting.
+   */
+  sortedRowModel?: (table: any) => () => RowModel<any, any>;
+  /**
+   * Registry of sorting functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `sortFn` on column
+   * definitions, with full inference. Import the built-in sorting functions
+   * you use individually and register them by their conventional names:
+   * `sortFns: { alphanumeric: sortFn_alphanumeric, myCustomSortFn }`. Spreading
+   * the exported `sortFns` registry also works, but puts every built-in
+   * sorting function in your bundle.
+   */
+  sortFns?: Record<string, SortFn<any, any>>;
+  /**
+   * Type-only slot for declaring the type of this table's `options.meta`.
+   *
+   * Pass a phantom value: `tableMeta: {} as MyTableMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `TableMeta` interface applies.
+   */
+  tableMeta?: object;
+}
+/**
+ * Lifecycle hooks and defaults contributed by a table feature.
+ *
+ * Feature objects are registered in the table's `features` option. They can
+ * contribute default state/options, default column definitions, table APIs,
+ * shared prototype APIs for rows/columns/headers/cells, and per-instance data
+ * for tables, columns, rows, headers, header groups, and cells.
+ */
+interface TableFeature {
+  /**
+   * Adds feature methods to the shared cell prototype for a table.
+   *
+   * This runs lazily the first time a cell is constructed for a table. Methods
+   * assigned here are shared by every cell instance created by that table, so
+   * this hook should be used for APIs and memoized methods rather than
+   * per-cell mutable data.
+   */
+  assignCellPrototype?: <TFeatures extends TableFeatures, TData extends RowData$2>(prototype: Record<string, any>, table: Table<TFeatures, TData>) => void;
+  /**
+   * Adds feature methods to the shared column prototype for a table.
+   *
+   * This runs lazily the first time a column is constructed for a table.
+   * Methods assigned here are shared by every column instance created by that
+   * table, so this hook should be used for APIs and memoized methods rather
+   * than per-column mutable data.
+   */
+  assignColumnPrototype?: <TFeatures extends TableFeatures, TData extends RowData$2>(prototype: Record<string, any>, table: Table<TFeatures, TData>) => void;
+  /**
+   * Adds feature methods to the shared header prototype for a table.
+   *
+   * This runs lazily the first time a header is constructed for a table.
+   * Methods assigned here are shared by every header instance created by that
+   * table, so this hook should be used for APIs and memoized methods rather
+   * than per-header mutable data.
+   */
+  assignHeaderPrototype?: <TFeatures extends TableFeatures, TData extends RowData$2>(prototype: Record<string, any>, table: Table<TFeatures, TData>) => void;
+  /**
+   * Adds feature methods to the shared row prototype for a table.
+   *
+   * This runs lazily the first time a row is constructed for a table. Methods
+   * assigned here are shared by every row instance created by that table, so
+   * this hook should be used for APIs and memoized methods rather than per-row
+   * mutable data.
+   */
+  assignRowPrototype?: <TFeatures extends TableFeatures, TData extends RowData$2>(prototype: Record<string, any>, table: Table<TFeatures, TData>) => void;
+  /**
+   * Adds feature APIs directly to the table instance.
+   *
+   * The table is a singleton, unlike rows, columns, headers, and cells, so
+   * table APIs are assigned directly instead of through a shared prototype.
+   * This hook is exclusively for assigning table methods. It runs after
+   * options, state atoms, and the store have been created and after every
+   * feature's `initTableInstanceData` hook has completed.
+   */
+  constructTableAPIs?: <TFeatures extends TableFeatures, TData extends RowData$2>(table: Table<TFeatures, TData>) => void;
+  /**
+   * Returns default column definition options contributed by this feature.
+   *
+   * These defaults are merged into the table's default column definition before
+   * `options.defaultColumn` and before each user-supplied column definition is
+   * resolved, so users can override values supplied here.
+   */
+  getDefaultColumnDef?: <TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData>() => ColumnDefBase_All<TFeatures, TData, TValue>;
+  /**
+   * Returns default table options contributed by this feature.
+   *
+   * This runs while table options are being resolved. Use it for option
+   * defaults such as feature enablement flags and default state-updater
+   * callbacks. User-supplied table options take precedence over values returned
+   * here.
+   */
+  getDefaultTableOptions?: <TFeatures extends TableFeatures, TData extends RowData$2>(table: Table<TFeatures, TData>) => Partial<TableOptions_All<TFeatures, TData>>;
+  /**
+   * Returns this feature's initial table state.
+   *
+   * The incoming `initialState` contains state accumulated from earlier
+   * features and user-provided initial state. Return a complete state object
+   * for this feature, preserving `initialState` so user-provided values can
+   * override feature defaults.
+   */
+  getInitialState?: (initialState: Partial<TableState_All>) => TableState_All;
+  /**
+   * Initializes mutable, non-reactive data owned by this feature on the table
+   * instance.
+   *
+   * This runs once during table construction after options, state atoms, and
+   * the store are available. Features are processed in a single pass in
+   * registration order, with each feature's instance data initialized just
+   * before its own `constructTableAPIs` hook, so this hook may rely on data
+   * and APIs of features registered earlier. Use `constructTableAPIs`
+   * exclusively for assigning table methods. Table resets do not rerun this
+   * hook; use `resetTableInstanceData` to clear transient instance data
+   * instead.
+   */
+  initTableInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2>(table: Table<TFeatures, TData>) => void;
+  /**
+   * Initializes instance-specific data on each cell.
+   *
+   * This runs for every constructed cell after core cell fields such as `id`,
+   * `column`, and `row` have been assigned. Cells are constructed lazily on
+   * first access per row/column pair and cached, so this runs once per cell
+   * instance. Use this for per-cell mutable data, caches, or annotations.
+   * Shared methods should be assigned via `assignCellPrototype` instead.
+   */
+  initCellInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>) => void;
+  /**
+   * Initializes instance-specific data on each column.
+   *
+   * This runs for every constructed column after core column fields such as
+   * `id`, `depth`, `parent`, `columnDef`, and `columns` have been assigned.
+   * Use this for per-column mutable data, caches, or annotations. Shared
+   * methods should be assigned via `assignColumnPrototype` instead.
+   */
+  initColumnInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData>(column: Column$2<TFeatures, TData, TValue>) => void;
+  /**
+   * Initializes instance-specific data on each header group.
+   *
+   * This runs for every constructed header group after `depth`, `id`, and the
+   * fully populated `headers` array have been assigned. Header groups have no
+   * shared prototype, so this is their only per-instance extension point.
+   * Header groups are reconstructed whenever they recompute (e.g. column
+   * visibility, order, or pinning changes), so this reruns on every rebuild.
+   */
+  initHeaderGroupInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2>(headerGroup: HeaderGroup<TFeatures, TData>) => void;
+  /**
+   * Initializes instance-specific data on each header.
+   *
+   * This runs for every constructed header after core header fields such as
+   * `id`, `column`, `depth`, `index`, and `isPlaceholder` have been assigned,
+   * but before `subHeaders` are populated and before `headerGroup` is linked.
+   * Headers are reconstructed on every header group rebuild, so this reruns
+   * on every rebuild. Use this for per-header mutable data, caches, or
+   * annotations. Shared methods should be assigned via `assignHeaderPrototype`
+   * instead.
+   */
+  initHeaderInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2, TValue extends CellData = CellData>(header: Header<TFeatures, TData, TValue>) => void;
+  /**
+   * Initializes instance-specific data on each row.
+   *
+   * This runs for every constructed row after core row fields such as `id`,
+   * `index`, `depth`, `original`, `parentId`, and `subRows` have been assigned.
+   * Use this for per-row mutable data, caches, or annotations. Shared methods
+   * should be assigned via `assignRowPrototype` instead.
+   */
+  initRowInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2>(row: Row<TFeatures, TData>) => void;
+  /**
+   * Resets mutable, non-reactive table-instance data owned by this feature.
+   *
+   * This runs after internally owned state atoms have been restored to
+   * `table.initialState` by `table.reset()`. It is intended for transient
+   * feature data, not table state slices or externally controlled state.
+   */
+  resetTableInstanceData?: <TFeatures extends TableFeatures, TData extends RowData$2>(table: Table<TFeatures, TData>) => void;
+}
+//#endregion
+//#region ../../node_modules/@tanstack/table-core/dist/core/cells/coreCellsFeature.d.ts
+//#region src/core/cells/coreCellsFeature.d.ts
+/**
+ * Core feature that adds cell value, render, and context APIs.
+ */
+declare const coreCellsFeature: TableFeature;
+//#endregion
+//#region src/components/data-table.d.ts
+declare const features: {
+  columnFilteringFeature: TableFeature;
+  rowSortingFeature: TableFeature;
+  rowPaginationFeature: TableFeature;
+  rowSelectionFeature: TableFeature;
+  columnVisibilityFeature: TableFeature;
+  filteredRowModel: (table: Table<any, any>) => () => RowModel<any, any>;
+  sortedRowModel: (table: Table<any, any>) => () => RowModel<any, any>;
+  paginatedRowModel: (table: Table<any, any>) => () => RowModel<any, any>;
+  filterFns: {
+    includesString: CreatedFilterFn<any, any>;
+    inNumberRange: CreatedFilterFn<any, any>;
+    equals: CreatedFilterFn<any, any>;
+    arrIncludes: CreatedFilterFn<any, any>;
+    inDateRange: CreatedFilterFn<any, any>;
+    weakEquals: CreatedFilterFn<any, any>;
+  };
+  sortFns: {
+    alphanumeric: CreatedSortFn<any, any>;
+    text: CreatedSortFn<any, any>;
+    datetime: CreatedSortFn<any, any>;
+    basic: CreatedSortFn<any, any>;
+  };
+};
+type ColumnDef$1<TData extends RowData, TValue = unknown> = ColumnDef<typeof features, TData, TValue>;
+type Column$1<TData extends RowData, TValue = unknown> = Column<typeof features, TData, TValue>;
+type TanStackTable<TData extends RowData> = ReactTable<typeof features, TData>;
+type DataTableToolbarActions<TData extends RowData> = React.ReactNode | ((table: TanStackTable<TData>) => React.ReactNode);
+type DataTableLabels = {
+  filterPlaceholder: string;
+  filterColumnSelectorLabel: string;
+  emptyMessage: React.ReactNode;
+  columnsButton: string;
+  rowsPerPage: string;
+  pageOf: (current: number, total: number) => React.ReactNode;
+  goToFirstPage: string;
+  goToPreviousPage: string;
+  goToNextPage: string;
+  goToLastPage: string;
+  selectAllRows: string;
+  selectRow: string;
+};
+declare const defaultDataTableLabels: DataTableLabels;
+type DataTableProps<TData extends RowData, TValue = unknown> = {
+  columns: ColumnDef$1<TData, TValue>[];
+  data: TData[];
+  getRowId?: (originalRow: TData, index: number, parent?: {
+    id: string;
+  }) => string;
+  filterColumns?: string | string[];
+  pageSize?: number;
+  pageSizeOptions?: number[];
+  enableRowSelection?: boolean;
+  enableSorting?: boolean;
+  showPagination?: boolean;
+  showColumnVisibility?: boolean;
+  toolbarActions?: DataTableToolbarActions<TData>;
+  labels?: Partial<DataTableLabels>;
+  className?: string;
+  tableClassName?: string;
+  variant?: TableProps['variant'];
+};
+type DataTableColumnHeaderProps<TData extends RowData, TValue> = React.ComponentProps<'div'> & {
+  column: Column$1<TData, TValue>;
+  title: React.ReactNode;
+};
+type DataTablePaginationProps<TData extends RowData> = React.ComponentProps<'div'> & {
+  table?: TanStackTable<TData>;
+  pageSizeOptions?: number[];
+  labels?: Partial<DataTableLabels>;
+};
+type DataTableViewOptionsProps<TData extends RowData> = React.ComponentProps<typeof Button> & {
+  table?: TanStackTable<TData>;
+  label?: React.ReactNode;
+};
+type UseDataTableOptions<TData extends RowData, TValue = unknown> = {
+  columns: ColumnDef$1<TData, TValue>[];
+  data: TData[];
+  getRowId?: (originalRow: TData, index: number, parent?: {
+    id: string;
+  }) => string;
+  pageSize?: number;
+  enableRowSelection?: boolean;
+  enableSorting?: boolean;
+  enablePagination?: boolean;
+  labels?: Partial<DataTableLabels>;
+};
+type DataTableRootProps<TData extends RowData, TValue = unknown> = {
+  labels?: Partial<DataTableLabels>;
+  className?: string;
+  children: React.ReactNode;
+} & ({
+  table: TanStackTable<TData>;
+  columns?: never;
+  data?: never;
+} | (Omit<UseDataTableOptions<TData, TValue>, 'labels'> & {
+  table?: never;
+}));
+type DataTableToolbarProps<TData extends RowData> = {
+  filterColumns?: string | string[];
+  showColumnVisibility?: boolean;
+  toolbarActions?: DataTableToolbarActions<TData>;
+  labels?: Partial<DataTableLabels>;
+  className?: string;
+};
+type DataTableHeaderProps = {
+  className?: string;
+};
+type DataTableBodyProps = {
+  emptyMessage?: React.ReactNode;
+  className?: string;
+};
+type DataTableContextValue<TData extends RowData> = {
+  table: TanStackTable<TData>;
+  labels: DataTableLabels;
+};
+declare function useDataTableContext<TData extends RowData>(): DataTableContextValue<TData>;
+declare function useDataTable<TData extends RowData, TValue = unknown>({ columns, data, getRowId, pageSize, enableRowSelection, enableSorting, enablePagination, labels }: UseDataTableOptions<TData, TValue>): TanStackTable<TData>;
+declare function DataTableRoot<TData extends RowData, TValue = unknown>(props: DataTableRootProps<TData, TValue>): React.JSX.Element;
+declare function DataTableColumnHeader<TData extends RowData, TValue>({ column, title, className, ...props }: DataTableColumnHeaderProps<TData, TValue>): React.JSX.Element;
+declare function DataTableViewOptions<TData extends RowData>({ table: tableProp, label, className, ...props }: DataTableViewOptionsProps<TData>): React.JSX.Element | null;
+declare function DataTableToolbar<TData extends RowData>({ filterColumns, showColumnVisibility, toolbarActions, labels: labelsOverride, className }: DataTableToolbarProps<TData>): React.JSX.Element | null;
+declare function DataTableHeader<TData extends RowData>({ className }?: DataTableHeaderProps): React.JSX.Element;
+declare function DataTableBody<TData extends RowData>({ emptyMessage, className }?: DataTableBodyProps): React.JSX.Element;
+declare function DataTablePagination<TData extends RowData>({ table: tableProp, pageSizeOptions, labels: labelsOverride, className, ...props }: DataTablePaginationProps<TData>): React.JSX.Element;
+declare function createDataTableSelectColumn<TData extends RowData>(options?: {
+  labels?: Pick<Partial<DataTableLabels>, 'selectAllRows' | 'selectRow'>;
+}): ColumnDef$1<TData>;
+declare function DataTable<TData extends RowData, TValue = unknown>({ columns, data, getRowId, filterColumns, pageSize, pageSizeOptions, enableRowSelection, enableSorting, showPagination, showColumnVisibility, toolbarActions, labels, className, tableClassName, variant }: DataTableProps<TData, TValue>): React.JSX.Element;
+//#endregion
+export { createDataTableSelectColumn as C, useDataTableContext as E, UseDataTableOptions as S, useDataTable as T, DataTableToolbarProps as _, DataTableBodyProps as a, RowData$1 as b, DataTableHeader as c, DataTablePagination as d, DataTablePaginationProps as f, DataTableToolbar as g, DataTableRootProps as h, DataTableBody as i, DataTableHeaderProps as l, DataTableRoot as m, ColumnDef$1 as n, DataTableColumnHeader as o, DataTableProps as p, DataTable as r, DataTableColumnHeaderProps as s, Column$1 as t, DataTableLabels as u, DataTableViewOptions as v, defaultDataTableLabels as w, TanStackTable as x, DataTableViewOptionsProps as y };
+//# sourceMappingURL=data-table-DXNWHN9R.d.ts.map