fastapi-rtk 2.1.5 → 2.2.0

package/dist/.external/lib/@tanstack/table-core/features/RowSorting.d.ts

@@ -0,0 +1,237 @@
+import { RowModel } from '..';
+import { BuiltInSortingFn } from '../sortingFns';
+import { OnChangeFn, Table, Row, Updater, RowData, SortingFns, TableFeature } from '../types';
+export type SortDirection = 'asc' | 'desc';
+export interface ColumnSort {
+    desc: boolean;
+    id: string;
+}
+export type SortingState = ColumnSort[];
+export interface SortingTableState {
+    sorting: SortingState;
+}
+export interface SortingFn<TData extends RowData> {
+    (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number;
+}
+export type CustomSortingFns<TData extends RowData> = Record<string, SortingFn<TData>>;
+export type SortingFnOption<TData extends RowData> = 'auto' | keyof SortingFns | BuiltInSortingFn | SortingFn<TData>;
+export interface SortingColumnDef<TData extends RowData> {
+    /**
+     * Enables/Disables multi-sorting for this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultisort)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableMultiSort?: boolean;
+    /**
+     * Enables/Disables sorting for this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    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, eg. a ranking (1st, 2nd, 3rd) or golf-like scoring
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#invertsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    invertSorting?: boolean;
+    /**
+     * Set to `true` for sorting toggles on this column to start in the descending direction.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortdescfirst)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortDescFirst?: boolean;
+    /**
+     * The sorting function to use with this column.
+     * - A `string` referencing a built-in sorting function
+     * - A custom sorting function
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortingfn)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortingFn?: SortingFnOption<TData>;
+    /**
+     * The priority of undefined values when sorting this column.
+     * - `false`
+     *   - Undefined values will be considered tied and need to be sorted by the next column filter or original index (whichever applies)
+     * - `-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)
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortundefined)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortUndefined?: false | -1 | 1 | 'first' | 'last';
+}
+export interface SortingColumn<TData extends RowData> {
+    /**
+     * Removes this column from the table's sorting state
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#clearsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    clearSorting: () => void;
+    /**
+     * Returns a sort direction automatically inferred based on the columns values.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getautosortdir)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getAutoSortDir: () => SortDirection;
+    /**
+     * Returns a sorting function automatically inferred based on the columns values.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getautosortingfn)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getAutoSortingFn: () => SortingFn<TData>;
+    /**
+     * Returns whether this column can be multi-sorted.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getcanmultisort)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getCanMultiSort: () => boolean;
+    /**
+     * Returns whether this column can be sorted.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getcansort)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getCanSort: () => boolean;
+    /**
+     * Returns the first direction that should be used when sorting this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getfirstsortdir)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getFirstSortDir: () => SortDirection;
+    /**
+     * Returns the current sort direction of this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getissorted)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getIsSorted: () => false | SortDirection;
+    /**
+     * Returns the next sorting order.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getnextsortingorder)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getNextSortingOrder: () => SortDirection | false;
+    /**
+     * Returns the index position of this column's sorting within the sorting state
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortindex)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getSortIndex: () => number;
+    /**
+     * Returns the resolved sorting function to be used for this column
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortingfn)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getSortingFn: () => SortingFn<TData>;
+    /**
+     * Returns a function that can be used to toggle this column's sorting state. This is useful for attaching a click handler to the column header.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#gettogglesortinghandler)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getToggleSortingHandler: () => undefined | ((event: unknown) => void);
+    /**
+     * Toggles this columns sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#togglesorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+}
+interface SortingOptionsBase {
+    /**
+     * Enables/disables the ability to remove multi-sorts
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultiremove)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableMultiRemove?: boolean;
+    /**
+     * Enables/Disables multi-sorting for the table.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultisort)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableMultiSort?: boolean;
+    /**
+     * Enables/Disables sorting for the table.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableSorting?: boolean;
+    /**
+     * Enables/Disables the ability to remove sorting for the table.
+     * - If `true` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...
+     * - If `false` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesortingremoval)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableSortingRemoval?: boolean;
+    /**
+     * This function is used to retrieve the sorted row model. If using server-side sorting, this function is not required. To use client-side sorting, pass the exported `getSortedRowModel()` from your adapter to your table or implement your own.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortedrowmodel)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getSortedRowModel?: (table: Table<any>) => () => RowModel<any>;
+    /**
+     * 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.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#ismultisortevent)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    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.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#manualsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    manualSorting?: boolean;
+    /**
+     * Set a maximum number of columns that can be multi-sorted.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#maxmultisortcolcount)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    maxMultiSortColCount?: number;
+    /**
+     * If provided, this function will be called with an `updaterFn` when `state.sorting` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#onsortingchange)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    onSortingChange?: OnChangeFn<SortingState>;
+    /**
+     * If `true`, all sorts will default to descending as their first toggle state.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortdescfirst)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortDescFirst?: boolean;
+}
+type ResolvedSortingFns = keyof SortingFns extends never ? {
+    sortingFns?: Record<string, SortingFn<any>>;
+} : {
+    sortingFns: Record<keyof SortingFns, SortingFn<any>>;
+};
+export interface SortingOptions<TData extends RowData> extends SortingOptionsBase, ResolvedSortingFns {
+}
+export interface SortingInstance<TData extends RowData> {
+    _getSortedRowModel?: () => RowModel<TData>;
+    /**
+     * Returns the row model for the table before any sorting has been applied.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getpresortedrowmodel)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getPreSortedRowModel: () => RowModel<TData>;
+    /**
+     * Returns the row model for the table after sorting has been applied.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortedrowmodel)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    getSortedRowModel: () => RowModel<TData>;
+    /**
+     * Resets the **sorting** state to `initialState.sorting`, or `true` can be passed to force a default blank state reset to `[]`.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#resetsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    resetSorting: (defaultState?: boolean) => void;
+    /**
+     * Sets or updates the `state.sorting` state.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#setsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    setSorting: (updater: Updater<SortingState>) => void;
+}
+export declare const RowSorting: TableFeature;
+export {};

package/dist/.external/lib/@tanstack/table-core/filterFns.d.ts

@@ -0,0 +1,13 @@
+import { FilterFn } from './features/ColumnFiltering';
+export declare const filterFns: {
+    includesString: FilterFn<any>;
+    includesStringSensitive: FilterFn<any>;
+    equalsString: FilterFn<any>;
+    arrIncludes: FilterFn<any>;
+    arrIncludesAll: FilterFn<any>;
+    arrIncludesSome: FilterFn<any>;
+    equals: FilterFn<any>;
+    weakEquals: FilterFn<any>;
+    inNumberRange: FilterFn<any>;
+};
+export type BuiltInFilterFn = keyof typeof filterFns;

package/dist/.external/lib/@tanstack/table-core/index.d.ts

@@ -0,0 +1,34 @@
+export * from './columnHelper';
+export * from './types';
+export * from './core/cell';
+export * from './core/column';
+export * from './core/headers';
+export * from './core/row';
+export * from './core/table';
+export * from './features/ColumnFaceting';
+export * from './features/ColumnFiltering';
+export * from './features/ColumnGrouping';
+export * from './features/ColumnOrdering';
+export * from './features/ColumnPinning';
+export * from './features/ColumnSizing';
+export * from './features/ColumnVisibility';
+export * from './features/GlobalFaceting';
+export * from './features/GlobalFiltering';
+export * from './features/RowExpanding';
+export * from './features/RowPagination';
+export * from './features/RowPinning';
+export * from './features/RowSelection';
+export * from './features/RowSorting';
+export * from './utils';
+export * from './utils/getCoreRowModel';
+export * from './utils/getExpandedRowModel';
+export * from './utils/getFacetedMinMaxValues';
+export * from './utils/getFacetedRowModel';
+export * from './utils/getFacetedUniqueValues';
+export * from './utils/getFilteredRowModel';
+export * from './utils/getGroupedRowModel';
+export * from './utils/getPaginationRowModel';
+export * from './utils/getSortedRowModel';
+export * from './aggregationFns';
+export * from './filterFns';
+export * from './sortingFns';

package/dist/.external/lib/@tanstack/table-core/sortingFns.d.ts

@@ -0,0 +1,11 @@
+import { SortingFn } from './features/RowSorting';
+export declare const reSplitAlphaNumeric: RegExp;
+export declare const sortingFns: {
+    alphanumeric: SortingFn<any>;
+    alphanumericCaseSensitive: SortingFn<any>;
+    text: SortingFn<any>;
+    textCaseSensitive: SortingFn<any>;
+    datetime: SortingFn<any>;
+    basic: SortingFn<any>;
+};
+export type BuiltInSortingFn = keyof typeof sortingFns;

package/dist/.external/lib/@tanstack/table-core/types.d.ts

@@ -0,0 +1,119 @@
+import { CoreOptions, CoreTableState, CoreInstance } from './core/table';
+import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/ColumnVisibility';
+import { ColumnOrderColumn, ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/ColumnOrdering';
+import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/ColumnPinning';
+import { RowPinningInstance, RowPinningOptions, RowPinningRow, RowPinningTableState } from './features/RowPinning';
+import { CoreHeader, CoreHeaderGroup, HeaderContext, HeadersInstance } from './core/headers';
+import { FacetedColumn, FacetedOptions } from './features/ColumnFaceting';
+import { GlobalFacetingInstance } from './features/GlobalFaceting';
+import { ColumnFiltersColumn, ColumnFiltersColumnDef, ColumnFiltersInstance, ColumnFiltersOptions, ColumnFiltersRow, ColumnFiltersTableState } from './features/ColumnFiltering';
+import { GlobalFilterColumn, GlobalFilterColumnDef, GlobalFilterInstance, GlobalFilterOptions, GlobalFilterTableState } from './features/GlobalFiltering';
+import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/RowSorting';
+import { GroupingCell, GroupingColumn, GroupingColumnDef, GroupingInstance, GroupingOptions, GroupingRow, GroupingTableState } from './features/ColumnGrouping';
+import { ExpandedInstance, ExpandedOptions, ExpandedTableState, ExpandedRow } from './features/RowExpanding';
+import { ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingHeader, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingTableState } from './features/ColumnSizing';
+import { PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationTableState } from './features/RowPagination';
+import { RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionTableState } from './features/RowSelection';
+import { CoreRow } from './core/row';
+import { PartialKeys, UnionToIntersection } from './utils';
+import { CellContext, CoreCell } from './core/cell';
+import { CoreColumn } from './core/column';
+export interface TableFeature<TData extends RowData = any> {
+    createCell?: (cell: Cell<TData, unknown>, column: Column<TData>, row: Row<TData>, table: Table<TData>) => void;
+    createColumn?: (column: Column<TData, unknown>, table: Table<TData>) => void;
+    createHeader?: (header: Header<TData, unknown>, table: Table<TData>) => void;
+    createRow?: (row: Row<TData>, table: Table<TData>) => void;
+    createTable?: (table: Table<TData>) => void;
+    getDefaultColumnDef?: () => Partial<ColumnDef<TData, unknown>>;
+    getDefaultOptions?: (table: Table<TData>) => Partial<TableOptionsResolved<TData>>;
+    getInitialState?: (initialState?: InitialTableState) => Partial<TableState>;
+}
+export interface TableMeta<TData extends RowData> {
+}
+export interface ColumnMeta<TData extends RowData, TValue> {
+}
+export interface FilterMeta {
+}
+export interface FilterFns {
+}
+export interface SortingFns {
+}
+export interface AggregationFns {
+}
+export type Updater<T> = T | ((old: T) => T);
+export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+export type RowData = unknown | object | any[];
+export type AnyRender = (Comp: any, props: any) => any;
+export interface Table<TData extends RowData> extends CoreInstance<TData>, HeadersInstance<TData>, VisibilityInstance<TData>, ColumnOrderInstance<TData>, ColumnPinningInstance<TData>, RowPinningInstance<TData>, ColumnFiltersInstance<TData>, GlobalFilterInstance<TData>, GlobalFacetingInstance<TData>, SortingInstance<TData>, GroupingInstance<TData>, ColumnSizingInstance, ExpandedInstance<TData>, PaginationInstance<TData>, RowSelectionInstance<TData> {
+}
+interface FeatureOptions<TData extends RowData> extends VisibilityOptions, ColumnOrderOptions, ColumnPinningOptions, RowPinningOptions<TData>, FacetedOptions<TData>, ColumnFiltersOptions<TData>, GlobalFilterOptions<TData>, SortingOptions<TData>, GroupingOptions, ExpandedOptions<TData>, ColumnSizingOptions, PaginationOptions, RowSelectionOptions<TData> {
+}
+export interface TableOptionsResolved<TData extends RowData> extends CoreOptions<TData>, FeatureOptions<TData> {
+}
+export interface TableOptions<TData extends RowData> extends PartialKeys<TableOptionsResolved<TData>, 'state' | 'onStateChange' | 'renderFallbackValue'> {
+}
+export interface TableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, RowPinningTableState, ColumnFiltersTableState, GlobalFilterTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationTableState, RowSelectionTableState {
+}
+interface CompleteInitialTableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, RowPinningTableState, ColumnFiltersTableState, GlobalFilterTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationInitialTableState, RowSelectionTableState {
+}
+export interface InitialTableState extends Partial<CompleteInitialTableState> {
+}
+export interface Row<TData extends RowData> extends CoreRow<TData>, VisibilityRow<TData>, ColumnPinningRow<TData>, RowPinningRow, ColumnFiltersRow<TData>, GroupingRow, RowSelectionRow, ExpandedRow {
+}
+export interface RowModel<TData extends RowData> {
+    rows: Row<TData>[];
+    flatRows: Row<TData>[];
+    rowsById: Record<string, Row<TData>>;
+}
+export type AccessorFn<TData extends RowData, TValue = unknown> = (originalRow: TData, index: number) => TValue;
+export type ColumnDefTemplate<TProps extends object> = string | ((props: TProps) => any);
+export type StringOrTemplateHeader<TData, TValue> = string | ColumnDefTemplate<HeaderContext<TData, TValue>>;
+export interface StringHeaderIdentifier {
+    header: string;
+    id?: string;
+}
+export interface IdIdentifier<TData extends RowData, TValue> {
+    id: string;
+    header?: StringOrTemplateHeader<TData, TValue>;
+}
+type ColumnIdentifiers<TData extends RowData, TValue> = IdIdentifier<TData, TValue> | StringHeaderIdentifier;
+interface ColumnDefExtensions<TData extends RowData, TValue = unknown> extends VisibilityColumnDef, ColumnPinningColumnDef, ColumnFiltersColumnDef<TData>, GlobalFilterColumnDef, SortingColumnDef<TData>, GroupingColumnDef<TData, TValue>, ColumnSizingColumnDef {
+}
+export interface ColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefExtensions<TData, TValue> {
+    getUniqueValues?: AccessorFn<TData, unknown[]>;
+    footer?: ColumnDefTemplate<HeaderContext<TData, TValue>>;
+    cell?: ColumnDefTemplate<CellContext<TData, TValue>>;
+    meta?: ColumnMeta<TData, TValue>;
+}
+export interface IdentifiedColumnDef<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+    id?: string;
+    header?: StringOrTemplateHeader<TData, TValue>;
+}
+export type DisplayColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
+interface GroupColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+    columns?: ColumnDef<TData, any>[];
+}
+export type GroupColumnDef<TData extends RowData, TValue = unknown> = GroupColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
+export interface AccessorFnColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+    accessorFn: AccessorFn<TData, TValue>;
+}
+export type AccessorFnColumnDef<TData extends RowData, TValue = unknown> = AccessorFnColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
+export interface AccessorKeyColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+    id?: string;
+    accessorKey: (string & {}) | keyof TData;
+}
+export type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = AccessorKeyColumnDefBase<TData, TValue> & Partial<ColumnIdentifiers<TData, TValue>>;
+export type AccessorColumnDef<TData extends RowData, TValue = unknown> = AccessorKeyColumnDef<TData, TValue> | AccessorFnColumnDef<TData, TValue>;
+export type ColumnDef<TData extends RowData, TValue = unknown> = DisplayColumnDef<TData, TValue> | GroupColumnDef<TData, TValue> | AccessorColumnDef<TData, TValue>;
+export type ColumnDefResolved<TData extends RowData, TValue = unknown> = Partial<UnionToIntersection<ColumnDef<TData, TValue>>> & {
+    accessorKey?: string;
+};
+export interface Column<TData extends RowData, TValue = unknown> extends CoreColumn<TData, TValue>, ColumnVisibilityColumn, ColumnPinningColumn, FacetedColumn<TData>, ColumnFiltersColumn<TData>, GlobalFilterColumn, SortingColumn<TData>, GroupingColumn<TData>, ColumnSizingColumn, ColumnOrderColumn {
+}
+export interface Cell<TData extends RowData, TValue> extends CoreCell<TData, TValue>, GroupingCell {
+}
+export interface Header<TData extends RowData, TValue> extends CoreHeader<TData, TValue>, ColumnSizingHeader {
+}
+export interface HeaderGroup<TData extends RowData> extends CoreHeaderGroup<TData> {
+}
+export {};

package/dist/.external/lib/@tanstack/table-core/utils/filterRowsUtils.d.ts

@@ -0,0 +1,2 @@
+import { Row, RowModel, Table, RowData } from '../types';
+export declare function filterRows<TData extends RowData>(rows: Row<TData>[], filterRowImpl: (row: Row<TData>) => any, table: Table<TData>): RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getCoreRowModel.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowModel, RowData } from '../types';
+export declare function getCoreRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getExpandedRowModel.d.ts

@@ -0,0 +1,7 @@
+import { Table, Row, RowModel, RowData } from '../types';
+export declare function getExpandedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+export declare function expandRows<TData extends RowData>(rowModel: RowModel<TData>): {
+    rows: Row<TData>[];
+    flatRows: Row<TData>[];
+    rowsById: Record<string, Row<TData>>;
+};

package/dist/.external/lib/@tanstack/table-core/utils/getFacetedMinMaxValues.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowData } from '../types';
+export declare function getFacetedMinMaxValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => undefined | [number, number];

package/dist/.external/lib/@tanstack/table-core/utils/getFacetedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowModel, RowData } from '../types';
+export declare function getFacetedRowModel<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getFacetedUniqueValues.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowData } from '../types';
+export declare function getFacetedUniqueValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => Map<any, number>;

package/dist/.external/lib/@tanstack/table-core/utils/getFilteredRowModel.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowModel, RowData } from '../types';
+export declare function getFilteredRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getGroupedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { RowData, RowModel, Table } from '../types';
+export declare function getGroupedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getPaginationRowModel.d.ts

@@ -0,0 +1,4 @@
+import { Table, RowModel, RowData } from '../types';
+export declare function getPaginationRowModel<TData extends RowData>(opts?: {
+    initialSync: boolean;
+}): (table: Table<TData>) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils/getSortedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { Table, RowModel, RowData } from '../types';
+export declare function getSortedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;

package/dist/.external/lib/@tanstack/table-core/utils.d.ts

@@ -0,0 +1,38 @@
+import { TableOptionsResolved, TableState, Updater } from './types';
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type Overwrite<T, U extends {
+    [TKey in keyof T]?: any;
+}> = Omit<T, keyof U> & U;
+export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
+export type IsKnown<T, Y, N> = unknown extends T ? N : Y;
+type ComputeRange<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : ComputeRange<N, [...Result, Result['length']]>;
+type Index40 = ComputeRange<40>[number];
+type IsTuple<T> = T extends readonly any[] & {
+    length: infer Length;
+} ? Length extends Index40 ? T : never : never;
+type AllowedIndexes<Tuple extends ReadonlyArray<any>, Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail['length']> : Keys;
+export type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5 ? never : unknown extends T ? string : T extends readonly any[] & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth> : T extends any[] ? DeepKeys<T[number], [...TDepth, any]> : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth> : never;
+type DeepKeysPrefix<T, TPrefix, TDepth extends any[]> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}` : never;
+export type DeepValue<T, TProp> = T extends Record<string | number, any> ? TProp extends `${infer TBranch}.${infer TDeepProp}` ? DeepValue<T[TBranch], TDeepProp> : T[TProp & string] : never;
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>;
+export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
+export declare function noop(): void;
+export declare function makeStateUpdater<K extends keyof TableState>(key: K, instance: unknown): (updater: Updater<TableState[K]>) => void;
+type AnyFunction = (...args: any) => any;
+export declare function isFunction<T extends AnyFunction>(d: any): d is T;
+export declare function isNumberArray(d: any): d is number[];
+export declare function flattenBy<TNode>(arr: TNode[], getChildren: (item: TNode) => TNode[]): TNode[];
+export declare function memo<TDeps extends readonly any[], TDepArgs, TResult>(getDeps: (depArgs?: TDepArgs) => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
+    key: any;
+    debug?: () => any;
+    onChange?: (result: TResult) => void;
+}): (depArgs?: TDepArgs) => TResult;
+export declare function getMemoOptions(tableOptions: Partial<TableOptionsResolved<any>>, debugLevel: 'debugAll' | 'debugCells' | 'debugTable' | 'debugColumns' | 'debugRows' | 'debugHeaders', key: string, onChange?: (result: any) => void): {
+    debug: () => boolean | undefined;
+    key: string | false;
+    onChange: ((result: any) => void) | undefined;
+};
+export {};

package/dist/.external/lib/@tanstack/virtual-core/index.d.ts

@@ -0,0 +1,133 @@
+export * from './utils.js';
+type ScrollDirection = 'forward' | 'backward';
+type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
+type ScrollBehavior = 'auto' | 'smooth';
+export interface ScrollToOptions {
+    align?: ScrollAlignment;
+    behavior?: ScrollBehavior;
+}
+type ScrollToOffsetOptions = ScrollToOptions;
+type ScrollToIndexOptions = ScrollToOptions;
+export interface Range {
+    startIndex: number;
+    endIndex: number;
+    overscan: number;
+    count: number;
+}
+type Key = number | string | bigint;
+export interface VirtualItem {
+    key: Key;
+    index: number;
+    start: number;
+    end: number;
+    size: number;
+    lane: number;
+}
+export interface Rect {
+    width: number;
+    height: number;
+}
+export declare const defaultKeyExtractor: (index: number) => number;
+export declare const defaultRangeExtractor: (range: Range) => number[];
+export declare const observeElementRect: <T extends Element>(instance: Virtualizer<T, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
+export declare const observeWindowRect: (instance: Virtualizer<Window, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
+type ObserveOffsetCallBack = (offset: number, isScrolling: boolean) => void;
+export declare const observeElementOffset: <T extends Element>(instance: Virtualizer<T, any>, cb: ObserveOffsetCallBack) => (() => void) | undefined;
+export declare const observeWindowOffset: (instance: Virtualizer<Window, any>, cb: ObserveOffsetCallBack) => (() => void) | undefined;
+export declare const measureElement: <TItemElement extends Element>(element: TItemElement, entry: ResizeObserverEntry | undefined, instance: Virtualizer<any, TItemElement>) => number;
+export declare const windowScroll: <T extends Window>(offset: number, { adjustments, behavior, }: {
+    adjustments?: number | undefined;
+    behavior?: ScrollBehavior | undefined;
+}, instance: Virtualizer<T, any>) => void;
+export declare const elementScroll: <T extends Element>(offset: number, { adjustments, behavior, }: {
+    adjustments?: number | undefined;
+    behavior?: ScrollBehavior | undefined;
+}, instance: Virtualizer<T, any>) => void;
+export interface VirtualizerOptions<TScrollElement extends Element | Window, TItemElement extends Element> {
+    count: number;
+    getScrollElement: () => TScrollElement | null;
+    estimateSize: (index: number) => number;
+    scrollToFn: (offset: number, options: {
+        adjustments?: number;
+        behavior?: ScrollBehavior;
+    }, instance: Virtualizer<TScrollElement, TItemElement>) => void;
+    observeElementRect: (instance: Virtualizer<TScrollElement, TItemElement>, cb: (rect: Rect) => void) => void | (() => void);
+    observeElementOffset: (instance: Virtualizer<TScrollElement, TItemElement>, cb: ObserveOffsetCallBack) => void | (() => void);
+    debug?: boolean;
+    initialRect?: Rect;
+    onChange?: (instance: Virtualizer<TScrollElement, TItemElement>, sync: boolean) => void;
+    measureElement?: (element: TItemElement, entry: ResizeObserverEntry | undefined, instance: Virtualizer<TScrollElement, TItemElement>) => number;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    initialOffset?: number | (() => number);
+    getItemKey?: (index: number) => Key;
+    rangeExtractor?: (range: Range) => Array<number>;
+    scrollMargin?: number;
+    gap?: number;
+    indexAttribute?: string;
+    initialMeasurementsCache?: Array<VirtualItem>;
+    lanes?: number;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    enabled?: boolean;
+    isRtl?: boolean;
+}
+export declare class Virtualizer<TScrollElement extends Element | Window, TItemElement extends Element> {
+    private unsubs;
+    options: Required<VirtualizerOptions<TScrollElement, TItemElement>>;
+    scrollElement: TScrollElement | null;
+    targetWindow: (Window & typeof globalThis) | null;
+    isScrolling: boolean;
+    private scrollToIndexTimeoutId;
+    measurementsCache: Array<VirtualItem>;
+    private itemSizeCache;
+    private pendingMeasuredCacheIndexes;
+    scrollRect: Rect | null;
+    scrollOffset: number | null;
+    scrollDirection: ScrollDirection | null;
+    private scrollAdjustments;
+    shouldAdjustScrollPositionOnItemSizeChange: undefined | ((item: VirtualItem, delta: number, instance: Virtualizer<TScrollElement, TItemElement>) => boolean);
+    elementsCache: Map<Key, TItemElement>;
+    private observer;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    constructor(opts: VirtualizerOptions<TScrollElement, TItemElement>);
+    setOptions: (opts: VirtualizerOptions<TScrollElement, TItemElement>) => void;
+    private notify;
+    private maybeNotify;
+    private cleanup;
+    _didMount: () => () => void;
+    _willUpdate: () => void;
+    private getSize;
+    private getScrollOffset;
+    private getFurthestMeasurement;
+    private getMeasurementOptions;
+    private getMeasurements;
+    calculateRange: () => {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    private getIndexes;
+    indexFromElement: (node: TItemElement) => number;
+    private _measureElement;
+    resizeItem: (index: number, size: number) => void;
+    measureElement: (node: TItemElement | null | undefined) => void;
+    getVirtualItems: () => VirtualItem[];
+    getVirtualItemForOffset: (offset: number) => VirtualItem | undefined;
+    getOffsetForAlignment: (toOffset: number, align: ScrollAlignment) => number;
+    getOffsetForIndex: (index: number, align?: ScrollAlignment) => readonly [number, "auto"] | readonly [number, "center"] | readonly [number, "end"] | readonly [number, "start"] | undefined;
+    private isDynamicMode;
+    private cancelScrollToIndex;
+    scrollToOffset: (toOffset: number, { align, behavior }?: ScrollToOffsetOptions) => void;
+    scrollToIndex: (index: number, { align: initialAlign, behavior }?: ScrollToIndexOptions) => void;
+    scrollBy: (delta: number, { behavior }?: ScrollToOffsetOptions) => void;
+    getTotalSize: () => number;
+    private _scrollToOffset;
+    measure: () => void;
+}