[{"name":"Table","comment":" Headless table state and row-model pipeline: a port of TanStack Table\ncore as pure functions.\n\nThere is no table instance. You own the `State`, you own the data, and every\nfunction here takes a `Config row` and a `State` and gives you a value back.\n\n\n# Columns and headers\n\nColumn and header types, the builders that assemble a `Config row`'s column\nlist, and the readers that walk it back.\n\n\n## Types\n\n@docs Column, Config, State, Row, RowModel, Header, HeaderGroup, Cell\n@docs Expanded, SortUndefined, GroupedColumnMode\n@docs SortColumn, ColumnFilter, Pagination, ColumnPinning, RowPinning, SizeDefaults\n\nElm cannot re-export the variants of a type that is declared in another\nmodule, so the three unions above are abstract here and come with one\nfunction per variant.\n\n@docs expandAll, expandedIds, expandedIdsOf\n@docs sortNullsFirst, sortNullsLast, sortNullsAsMinusOne, sortNullsAsPlusOne\n@docs groupedColumnsReorder, groupedColumnsRemove, groupedColumnsIgnore\n\n\n## Configuration\n\n@docs config, initialState\n@docs withGetRowId, withSubRows, withDefaultColumn, withGlobalFilterFn, withRowSelection\n\n\n## Building columns\n\n@docs column, group, display\n@docs withHeader, withFooter\n@docs withSortFn, withCustomSort, withSortDescFirst, withInvertSorting, withSortUndefined\n@docs withEnableSorting, withEnableMultiSort\n@docs withFilterFn, withCustomFilter, withEnableColumnFilter, withEnableGlobalFilter\n@docs withAggregationFn, withGetGroupingValue, withGetUniqueValues, withEnableGrouping\n@docs withEnableHiding, withEnablePinning\n@docs withSize, withMinSize, withMaxSize\n\n\n## Reading columns\n\n@docs columnId, columnHeader, columnFooter, columnDepth, columnColumns, columnParentId, columnAccessor\n@docs columnSize, columnMinSize, columnMaxSize\n@docs allColumns, leafColumns, visibleLeafColumns, findColumn\n@docs columnFlatColumns, columnLeafColumns\n\n\n## Headers\n\n@docs headerGroups, footerGroups, flatHeaders, leafHeaders, getLeafHeaders\n@docs headerId, headerColumnId, headerColSpan, headerRowSpan, headerDepth, headerIndex\n@docs headerIsPlaceholder, headerPlaceholderId, headerSubHeaders\n\n\n# Row models\n\nThe pipeline that turns your data into a row tree, the readers that walk one\nrow, and the faceted values later stages sample from it.\n\n\n## Reading rows\n\n@docs rowId, rowIndex, rowDepth, rowOriginal, rowSubRows, rowParentId, rowOriginalSubRows\n@docs rowGroupingColumnId, rowGroupingValue, rowLeafRows, rowAggregatedValues\n@docs getValue, getUniqueValues, getLeafRows, getParentRow, getParentRows, getAllCells\n@docs findRow, maxSubRowDepth\n\n\n## The pipeline\n\n@docs rows, rowsFromList, coreRowModel, coreRowModelFromList\n@docs filteredRowModel, groupedRowModel, sortedRowModel, expandedRowModel, paginatedRowModel\n\n\n## Faceting\n\n@docs facetedUniqueValues, facetedMinMax\n@docs facetedRowModel, globalFacetKey\n\n\n# Filtering\n\nColumn filters narrow a row model down to the rows that match; the global\nfilter runs the same comparison across every column that allows it. Every\nreader that has to guess something from the data (an `'auto'` filter\nfunction, for instance) takes a `RowModel row` to sample, exactly like\nTanStack, which samples the core or filtered row model for the same job.\n\n\n## Column filter state\n\n@docs getCanFilter, getIsFiltered, getFilterValue, getFilterIndex\n@docs getFilterFn, getAutoFilterFn, shouldAutoRemoveFilter\n@docs setColumnFilter, setColumnFilters, resetColumnFilters\n\n\n## Global filter state\n\n@docs getCanGlobalFilter, getGlobalFilterFn, globalAutoFilterFn\n@docs setGlobalFilter, resetGlobalFilter\n\n\n# Sorting\n\nOne or more columns order the rows; `withSortDescFirst`, `withInvertSorting`,\nand `withSortUndefined` tune how a single column compares.\n\n\n## Sort direction\n\n@docs SortDir, sortAsc, sortDesc\n\n\n## Sorting state\n\n@docs getCanSort, getCanMultiSort, getIsSorted, getSortIndex\n@docs getAutoSortFn, getSortFn, getAutoSortDir, getFirstSortDir, getNextSortingOrder\n@docs toggleSort, setSorting, clearSorting, resetSorting\n\n\n# Pagination\n\nSlices the pre-pagination row model into pages; `Config.pageCount` and\n`Config.rowCount` stand in for a server-side count when the table is not\npaginating in memory.\n\n\n## Pagination state\n\n@docs prePaginationRowModel, rowsInDisplayOrder, displayIndex\n@docs setPage, setPageSize, setPagination\n@docs resetPageIndex, resetPageSize, resetPagination\n@docs getPageCount, getPageOptions, getRowCount\n@docs getCanPreviousPage, getCanNextPage, getCanLastPage\n@docs previousPage, nextPage, firstPage, lastPage, unlimitedPageSize\n\n\n# Grouping and aggregation\n\nThe grouped row model replaces the rows with one group row per distinct\nvalue of every column in `State.grouping`, recursively, and rolls up every\nother column with an `AggregationFn`.\n\nGroup rows carry [`rowGroupingColumnId`](#rowGroupingColumnId),\n[`rowGroupingValue`](#rowGroupingValue), [`rowLeafRows`](#rowLeafRows), and\n[`rowAggregatedValues`](#rowAggregatedValues), and their ids are\n`\"columnId:groupingValue\"` joined to the parent group's id with `>`.\n\n\n## Grouping and expanding configuration\n\n@docs withRowCanExpand, withIsRowExpanded, withMaxAggregationDepth\n\n\n## Grouping state\n\n@docs getCanGroup, getIsGrouped, getGroupedIndex\n@docs toggleGrouping, setGrouping, resetGrouping\n@docs rowIsGrouped, rowGroupingValueFor, cellIsGrouped, cellIsPlaceholder\n@docs preGroupedRowModel\n\n\n## Aggregation\n\n@docs getAutoAggregationFn, getAggregationFn\n@docs aggregationValue, aggregationValueOf, cellIsAggregated\n\n\n# Expanding\n\nSplices the sub-rows of expanded rows back into the row list, according to\n`State.expanded`.\n\n\n## Expanded state\n\n@docs preExpandedRowModel\n@docs getCanExpand, getIsExpanded, getIsAllParentsExpanded\n@docs getCanSomeRowsExpand, getIsSomeRowsExpanded, getIsAllRowsExpanded, getExpandedDepth\n@docs toggleExpanded, toggleAllRowsExpanded, setExpanded, resetExpanded\n\n\n# Row selection\n\nRow selection propagates to sub-rows and reports `isSomeSelected` and\n`isAllSelected` per parent. Every transition is `... -> State -> State` so it\npipes, and every query takes the `Config` and the `State` first, then the\nrow model or column it is about.\n\n\n## Selection types\n\n@docs SubRowSelection, SelectOptions\n@docs noSubRowsSelected, someSubRowsSelected, allSubRowsSelected\n@docs defaultSelectOptions\n\nThese are abstract for the same reason as the types above, so they come with\none function per variant.\n\n\n## Selection state\n\n@docs toggleRowSelected, toggleRowSelectedWith\n@docs toggleAllRowsSelected, toggleAllPageRowsSelected, deselectAllRows\n@docs setRowSelection, resetRowSelection\n@docs selectRange, selectRangeWith, canSelectRange\n@docs getIsRowSelected, getIsSomeRowsSelected\n@docs getIsAllRowsSelected, getIsAllPageRowsSelected, getIsSomePageRowsSelected\n@docs getCanSelect, getCanSelectSubRows, getCanMultiSelect\n@docs getIsSomeSelected, getIsAllSubRowsSelected, subRowSelection\n@docs selectedRowIds, selectedRowModel\n\n\n# Pinning\n\nColumn pinning returns left, center, and right leaf column lists; row\npinning does the same for rows. Neither one touches the DOM.\n\n\n## Pinning types\n\n@docs ColumnPinPosition, ColumnRegion, RowPinPosition\n@docs PinRowOptions, PinnedRowsSource, PinnedColumns\n@docs pinnedLeft, pinnedRight, columnUnpinned\n@docs allColumnsRegion, leftColumnsRegion, centerColumnsRegion, rightColumnsRegion\n@docs pinnedTop, pinnedBottom, rowUnpinned\n@docs defaultPinRowOptions\n\nThese are abstract for the same reason as the types above, so they come with\none function per variant.\n\n\n## Column pinning\n\n@docs pinColumn, setColumnPinning, resetColumnPinning\n@docs columnCanPin, columnIsPinned, columnPinnedIndex\n@docs isSomeColumnsPinned, isSomeColumnsPinnedLeft, isSomeColumnsPinnedRight\n@docs leftLeafColumns, centerLeafColumns, rightLeafColumns, pinnedLeafColumns\n@docs leftVisibleLeafColumns, centerVisibleLeafColumns, rightVisibleLeafColumns\n@docs pinnedVisibleLeafColumns, pinnedColumns\n@docs leftHeaderGroups, centerHeaderGroups, rightHeaderGroups\n@docs leftFooterGroups, centerFooterGroups, rightFooterGroups\n@docs leftFlatHeaders, centerFlatHeaders, rightFlatHeaders\n@docs leftLeafHeaders, centerLeafHeaders, rightLeafHeaders\n@docs leftVisibleCells, centerVisibleCells, rightVisibleCells\n\n\n## Row pinning\n\n@docs pinRow, pinRowWith, setRowPinning, resetRowPinning\n@docs getIsRowPinned, getRowPinnedIndex, getCanPinRow\n@docs isSomeRowsPinned, isSomeRowsPinnedTop, isSomeRowsPinnedBottom\n@docs topRows, bottomRows, centerRows\n\n\n# Column ordering, visibility and sizing\n\nWhich columns render, in what order, and how wide each one is.\n\n\n## Column visibility\n\n@docs columnIsVisible, columnCanHide, toggleColumnVisibility, setColumnVisibility\n@docs resetColumnVisibility, toggleAllColumnsVisible\n@docs isAllColumnsVisible, isSomeColumnsVisible, visibleFlatColumns\n@docs visibleCells, visibleCellsByColumnId\n\n\n## Column order\n\n@docs setColumnOrder, resetColumnOrder, orderColumns, orderGroupedColumns\n@docs columnIndex, columnIsFirst, columnIsLast\n\n\n## Column sizing\n\n@docs getColumnSize, getColumnStart, getColumnAfter\n@docs setColumnSize, setColumnSizing, resetColumnSize, resetColumnSizing\n@docs getHeaderSize, getHeaderStart\n@docs totalSize, leftTotalSize, centerTotalSize, rightTotalSize\n\n\n# Column resizing\n\nDragging a column edge to a new width. The package holds the transient state\nof the drag and does the arithmetic; the pointer events, the handle, and the\nsubscription are yours.\n\n@docs ColumnResizingState, ColumnResizeMode, ColumnResizeDirection\n@docs resizeOnChange, resizeOnEnd, resizeLtr, resizeRtl\n\nThe two unions are abstract here for the same reason as the ones above, so\nthey come with one function per variant.\n\n@docs withEnableResizing\n@docs columnCanResize, columnIsResizing, headerCanResize, headerIsResizing\n@docs startColumnResize, updateColumnResize, endColumnResize\n@docs setColumnResizing, resetColumnResizing\n\n\n# Auto reset, filter meta, aggregation options\n\nThe three corners of TanStack that need a caller to stand in for the table\ninstance: the `autoReset*` scheduler, the per-row filter bookkeeping the\nfiltered row model writes, and the aggregation options that hand a column's\nvalue to the caller.\n\n\n## Auto reset\n\nTanStack schedules a reset of one state slice whenever a row-model stage\nrecomputes: the page index goes back to `0` when the data, the filters, the\nsorting or the grouping changed, the expanded rows collapse when the data,\nthe filters or the grouping changed, and a data change also clears the\nsorting and the cell selection when those are switched on.\n\nThere is no scheduler here, so [`autoReset`](#autoReset) is the whole thing\nas one pure step: produce your next `State` in `update`, then hand it and the\nprevious one over.\n\n@docs autoReset\n@docs withAutoResetAll, withAutoResetPageIndex, withAutoResetExpanded\n@docs withAutoResetSorting, withAutoResetCellSelection\n\n\n## Filter meta\n\n`_createFilteredRowModel` writes a pass/fail flag and an optional meta value\nonto every row it tests, for every filter it evaluates, and the fuzzy-filter\nexample then sorts by the rank its filter fn stored. The flags live on the\nrows [`filteredRowModel`](#filteredRowModel) returns; to read them for the\nrows it dropped, run [`taggedRowModel`](#taggedRowModel), which tags the same\nrows and drops nothing.\n\nThe global filter's verdict is stored under\n[`globalFacetKey`](#globalFacetKey), TanStack's `__global__`, and its meta\nunder the id of the column that produced it.\n\n@docs taggedRowModel\n@docs rowColumnFilters, rowColumnFiltersMeta, rowFilterMeta\n@docs withCustomFilterMeta\n\n\n## Aggregation options\n\nA column can aggregate with several functions at once, each under its own\nkey, with a function of the whole [`AggregationContext`](#AggregationContext)\nrather than of the values alone, or not at all, with the caller supplying the\nvalue instead.\n\n@docs AggregationContext, ContextAggregationFn\n@docs withAggregationFns, withContextAggregationFn, withGetAggregationValue\n@docs aggregationFnWithContext, withManualAggregation\n@docs aggregationResults, rowAggregationResults, aggregationValueById\n\n\n# Cell spanning and cell selection\n\nSpans merge adjacent cells; cell selection tracks rectangular ranges,\nfocus, and keyboard movement over the visible grid. Optional; ignore this\nsection if your table does not need either.\n\n\n## Span index types\n\n@docs CellSpanIndex, RowSpanContext\n\n\n## Cell spanning\n\n@docs withCellSpanning, withEnableCellSpanning\n@docs withSpanRows, withSpanRowsWhen, withSpanColumns, spanAllColumns\n@docs columnCanSpan, cellSpanIndex, cellSpanIndexRowIds, cellSpanIndexRowSpans\n@docs cellRowSpan, cellColSpan, cellIsCovered\n\n\n## Cell selection types\n\n@docs CellSelectionRange, CellSelectionOperation, CellSelectionMode, CellSelectionBounds\n@docs CellSelectionEdges, CellDirection, SelectionRows\n@docs includeCells, excludeCells\n@docs replaceSelection, includeSelection, excludeSelection\n@docs cellUp, cellDown, cellLeft, cellRight\n\n\n## Cell selection options\n\n@docs withCellSelection, withCellSelectionWhen\n@docs withCellRangeSelection, withMultiCellRangeSelection, withEnableCellSelection\n\n\n## Cell selection transitions\n\n@docs cellRange, setCellSelection, clearCellSelection\n@docs selectCellRange, selectCellRangeWith, selectAllCells, setFocusedCell\n@docs selectCell, extendCellSelectionTo, toggleCellSelection\n@docs moveCellSelection, extendCellSelection\n\n\n## Cell selection queries\n\n@docs cellCanSelect, cellIsSelected, cellIsFocused, cellTabIndex, cellSelectionEdges\n@docs focusedCell, cellSelectionBounds, cellSelectionMergeBounds, cellSelectionColumnIndexes\n@docs selectedCellIds, selectedCellCount, selectedCellRangesData\n@docs cellSelectionRowIds, cellSelectionColumnIds\n\n\n## Cell selection geometry\n\n@docs intersectCellSelectionBounds, subtractCellSelectionBounds, addCellSelectionBounds\n@docs mergeAdjacentCellSelectionBounds, expandCellSelectionBounds\n@docs applyCellSelectionBoundsOperations\n\n","unions":[],"aliases":[{"name":"AggregationContext","comment":" What one aggregation sees while it runs. Ports `AggregationContext`,\nminus its `column` and `table` members: there is no table instance and the\ncolumn is fixed by the call site.\n\n`rows` is the depth-selected frontier and `values` are that frontier's values\nfor `columnId`. `subRows` and `subRowValues` are the immediate sub-rows of a\ngroup row and the values they already carry, and are empty for root or\ncaller-supplied-row aggregation, where `groupingRow` is `Nothing` too.\n\n","args":["row"],"type":"Table.Internal.Types.AggregationContext row"},{"name":"Cell","comment":" One cell of one row, computed on demand.\n","args":[],"type":"Table.Internal.Types.Cell"},{"name":"CellDirection","comment":" One step of keyboard navigation.\n","args":[],"type":"Table.Internal.Types.CellDirection"},{"name":"CellSelectionBounds","comment":" A range resolved into inclusive display-order indexes. Rows are positions\nin [`rowsInDisplayOrder`](#rowsInDisplayOrder); columns are positions in the\nvisible leaf columns in render order.\n","args":[],"type":"Table.Internal.Types.CellSelectionBounds"},{"name":"CellSelectionEdges","comment":" Which sides of a selected cell sit on the outer boundary of the\nselection, for drawing a spreadsheet-style outline.\n","args":[],"type":"Table.Internal.Types.CellSelectionEdges"},{"name":"CellSelectionMode","comment":" Whether a write replaces the selection, adds a rectangle, or subtracts\none.\n","args":[],"type":"Table.Internal.Types.CellSelectionMode"},{"name":"CellSelectionOperation","comment":" How a range changes the selection the ranges before it produced.\n","args":[],"type":"Table.Internal.Types.CellSelectionOperation"},{"name":"CellSelectionRange","comment":" One rectangular cell selection, stored as its two defining corners. The\nanchor stays put while the focus corner moves during a shift-extend or a\ndrag, so the pair carries more than a normalized rectangle would. Build one\nwith [`cellRange`](#cellRange).\n","args":[],"type":"Table.Internal.Types.CellSelectionRange"},{"name":"CellSpanIndex","comment":" The cell span index of the rows a caller renders. Build it with\n[`cellSpanIndex`](#cellSpanIndex) and read it with\n[`cellRowSpan`](#cellRowSpan), [`cellColSpan`](#cellColSpan), and\n[`cellIsCovered`](#cellIsCovered).\n","args":[],"type":"Table.Internal.Types.CellSpanIndex"},{"name":"Column","comment":" A column definition. Build one with [`column`](#column),\n[`group`](#group), or [`display`](#display).\n","args":["row"],"type":"Table.Internal.Types.Column row"},{"name":"ColumnFilter","comment":" One entry of `State.columnFilters`.\n","args":[],"type":"Table.Internal.Types.ColumnFilter"},{"name":"ColumnPinPosition","comment":" Where a column is pinned: [`pinnedLeft`](#pinnedLeft),\n[`pinnedRight`](#pinnedRight), or [`columnUnpinned`](#columnUnpinned).\nTanStack calls these `'start'`, `'end'`, and `false`.\n","args":[],"type":"Table.Internal.Types.ColumnPinPosition"},{"name":"ColumnPinning","comment":" Column ids pinned to either edge.\n","args":[],"type":"Table.Internal.Types.ColumnPinning"},{"name":"ColumnRegion","comment":" Which slice of the visible leaf columns a query is about.\n[`allColumnsRegion`](#allColumnsRegion) is TanStack's absent `position`\nargument and means the whole visible list in table order.\n","args":[],"type":"Table.Internal.Types.ColumnRegion"},{"name":"ColumnResizeDirection","comment":" Which way a drag counts as growth: [`resizeLtr`](#resizeLtr) or\n[`resizeRtl`](#resizeRtl).\n","args":[],"type":"Table.Internal.Types.ColumnResizeDirection"},{"name":"ColumnResizeMode","comment":" When a drag commits the widths it computes: [`resizeOnChange`](#resizeOnChange)\non every pointer move, [`resizeOnEnd`](#resizeOnEnd) only when the drag ends.\n","args":[],"type":"Table.Internal.Types.ColumnResizeMode"},{"name":"ColumnResizingState","comment":" The transient state of one resize drag, `State.columnResizing`. It is\nempty between drags and is written by the three transitions below.\n\n    { columnSizingStart = List ( String, Float )\n    , deltaOffset = Maybe Float\n    , deltaPercentage = Maybe Float\n    , isResizingColumn = Maybe String\n    , startOffset = Maybe Float\n    , startSize = Maybe Float\n    }\n\n`columnSizingStart` is the width every leaf header under the dragged header\nhad when the drag began. TanStack's `isResizingColumn: false | string` is a\n`Maybe String` here.\n\n","args":[],"type":"Table.Internal.Types.ColumnResizingState"},{"name":"Config","comment":" Everything about a table that is not state: the columns, how to find row\nids and sub-rows, and every feature flag.\n\nIt is a plain record, so `{ cfg | manualSorting = True }` works for any flag\nthat has no builder. Later versions of this package may add fields, which is\na breaking change for code that pattern matches on the record but not for\nrecord update.\n\nFields, with the defaults [`config`](#config) sets:\n\n  - `columns : List (Column row)`\n  - `getRowId : Maybe (row -> Int -> Maybe String -> String)`, `Nothing` (index paths)\n  - `getSubRows : row -> List row`, none\n  - `manualSorting`, `manualFiltering`, `manualGrouping`, `manualExpanding`,\n    `manualPagination : Bool`, all `False`; `True` makes that stage return its input\n  - `enableSorting`, `enableMultiSort`, `enableSortingRemoval`,\n    `enableMultiRemove : Bool`, all `True`; `maxMultiSortColCount : Int`, unlimited;\n    `sortDescFirst : Maybe Bool`, `Nothing` (automatic per column)\n  - `enableFilters`, `enableColumnFilters`, `enableGlobalFilter : Bool`, all `True`;\n    `getColumnCanGlobalFilter : Maybe (Column row -> Bool)`, `Nothing` (strings and\n    numbers); `filterFromLeafRows : Bool`, `False`; `maxLeafRowFilterDepth : Int`,\n    `100`; `globalFilterFn : Maybe FilterFn`, `Nothing` (automatic)\n  - `enableGrouping : Bool`, `True`; `groupedColumnMode : GroupedColumnMode`,\n    [`groupedColumnsReorder`](#groupedColumnsReorder)\n  - `enableExpanding : Bool`, `True`; `getRowCanExpand`,\n    `getIsRowExpanded : Maybe (Row row -> Bool)`, `Nothing`;\n    `paginateExpandedRows : Bool`, `True`\n  - `pageCount`, `rowCount : Maybe Int`, `Nothing` (manual pagination only)\n  - `enableRowSelection`, `enableMultiRowSelection`, `enableSubRowSelection`,\n    `enableRowPinning : Row row -> Bool`, all `always True`;\n    `keepPinnedRows : Bool`, `True`\n  - `enableColumnPinning`, `enableHiding : Bool`, `True`;\n    `defaultColumn : SizeDefaults`, size 150, min 20, max unlimited\n  - `enableCellSpanning`, `enableCellSelection`, `enableCellRangeSelection`,\n    `enableMultiCellRangeSelection : Bool`, all `True`;\n    `cellSelectionFilter : Maybe (Cell -> Bool)`, `Nothing`\n  - `enableColumnResizing : Bool`, `True`; `columnResizeMode : ColumnResizeMode`,\n    [`resizeOnEnd`](#resizeOnEnd) (TanStack's default);\n    `columnResizeDirection : ColumnResizeDirection`, [`resizeLtr`](#resizeLtr)\n  - `manualAggregation : Bool`, `False`; `autoResetAll`, `autoResetPageIndex`,\n    `autoResetExpanded`, `autoResetSorting`, `autoResetCellSelection : Maybe Bool`,\n    all `Nothing` (TanStack's automatic rule: reset unless the matching\n    `manual*` flag is set)\n\n","args":["row"],"type":"Table.Internal.Types.Config row"},{"name":"ContextAggregationFn","comment":" An aggregation that reads the whole\n[`AggregationContext`](#AggregationContext) instead of only the values, which\nis TanStack's `AggregationFnDef.aggregate`. Build one with\n[`aggregationFnWithContext`](#aggregationFnWithContext).\n\nIt lives here rather than in `Table.AggregationFn` because that module is\nimported by the one that declares `Row` and so cannot mention it.\n\n","args":["row"],"type":"Table.Internal.Types.ContextAggregationFn row"},{"name":"Expanded","comment":" Which rows are expanded. `ExpandAll` is TanStack's `expanded: true`.\n","args":[],"type":"Table.Internal.Types.Expanded"},{"name":"GroupedColumnMode","comment":" What the leaf column list does with grouped columns.\n","args":[],"type":"Table.Internal.Types.GroupedColumnMode"},{"name":"Header","comment":" One header cell.\n","args":["row"],"type":"Table.Internal.Types.Header row"},{"name":"HeaderGroup","comment":" One header row.\n","args":["row"],"type":"Table.Internal.Types.HeaderGroup row"},{"name":"Pagination","comment":" The page the paginated row model returns.\n","args":[],"type":"Table.Internal.Types.Pagination"},{"name":"PinRowOptions","comment":" The options of [`pinRowWith`](#pinRowWith): pin the row's leaf rows and\nits ancestors along with it.\n","args":[],"type":"Table.Internal.Types.PinRowOptions"},{"name":"PinnedColumns","comment":" The three visible column slices of a pinned table.\n","args":["row"],"type":"Table.Internal.Types.PinnedColumns row"},{"name":"PinnedRowsSource","comment":" The two row models the pinned row lists read from. With\n`Config.keepPinnedRows` on, a pinned row is taken from `prePaginated` even\nwhen it is off the current page; with it off, only `current` is searched.\n","args":["row"],"type":"Table.Internal.Types.PinnedRowsSource row"},{"name":"Row","comment":" One row of a row model.\n","args":["row"],"type":"Table.Internal.Types.Row row"},{"name":"RowModel","comment":" The output of a pipeline stage: the row tree, the same rows flattened\ndepth first, and a lookup by row id.\n","args":["row"],"type":"Table.Internal.Types.RowModel row"},{"name":"RowPinPosition","comment":" Where a row is pinned: [`pinnedTop`](#pinnedTop),\n[`pinnedBottom`](#pinnedBottom), or [`rowUnpinned`](#rowUnpinned).\n","args":[],"type":"Table.Internal.Types.RowPinPosition"},{"name":"RowPinning","comment":" Row ids pinned to the top or the bottom.\n","args":[],"type":"Table.Internal.Types.RowPinning"},{"name":"RowSpanContext","comment":" What a `withSpanRowsWhen` predicate is given for each candidate row. The\nrun is anchored: `anchorRow` is the row whose cell renders the merged\ncontent, and every later row of the run is tested against it.\n","args":["row"],"type":"Table.Internal.Types.RowSpanContext row"},{"name":"SelectOptions","comment":" The options of a selection toggle. `selectChildren` also writes the\nrow's sub-tree; `deselectParents` drops the ancestors of a row that is being\ndeselected.\n","args":[],"type":"Table.Internal.Types.SelectOptions"},{"name":"SelectionRows","comment":" The two row models cell selection reads: `prePaginated` fixes the\ndisplay-order indexes a range resolves against, so a range spans pages, and\n`current` is the page a caller renders, which bounds keyboard navigation and\ncell spanning. Without pagination both are the same model.\n","args":["row"],"type":"Table.Internal.Types.SelectionRows row"},{"name":"SizeDefaults","comment":" The default sizing of a column, in pixels.\n","args":[],"type":"Table.Internal.Types.SizeDefaults"},{"name":"SortColumn","comment":" One entry of `State.sorting`.\n","args":[],"type":"Table.Internal.Types.SortColumn"},{"name":"SortDir","comment":" A sort direction.\n","args":[],"type":"Table.Internal.Types.SortDir"},{"name":"SortUndefined","comment":" Where `Null` values land when a column is sorted.\n","args":[],"type":"Table.Internal.Types.SortUndefined"},{"name":"State","comment":" Every state slice the pipeline reads. Start from\n[`initialState`](#initialState) and update it yourself, directly or through\nthe transition functions in this module.\n\n  - `sorting : List SortColumn`, in priority order\n  - `columnFilters : List ColumnFilter`\n  - `globalFilter : Value`, `Null` for none\n  - `grouping : List String`, column ids in grouping order\n  - `expanded : Expanded`\n  - `rowSelection : Set String`, selected row ids\n  - `pagination : Pagination`\n  - `columnOrder : List String`, empty for definition order\n  - `columnVisibility : Dict String Bool`, missing means visible\n  - `columnPinning : ColumnPinning`\n  - `columnSizing : Dict String Float`, missing means the column's own size\n  - `rowPinning : RowPinning`\n  - `cellSelection : List CellSelectionRange`\n\n","args":[],"type":"Table.Internal.Types.State"},{"name":"SubRowSelection","comment":" How much of a parent row's sub-tree is selected.\n","args":[],"type":"Table.Internal.Types.SubRowSelection"}],"values":[{"name":"addCellSelectionBounds","comment":" Add a rectangle to a disjoint set, keeping the set disjoint.\n","type":"List.List Table.CellSelectionBounds -> Table.CellSelectionBounds -> List.List Table.CellSelectionBounds"},{"name":"aggregationFnWithContext","comment":" The `AggregationFn.custom` of a fold that needs the context: the rows and\nvalues it is folding, the immediate sub-rows and their results, and the group\nrow the result is for.\n\nIt is here rather than in `Table.AggregationFn` because that module is\nimported by the one that declares `Row` and so cannot mention it.\n\n","type":"(Table.AggregationContext row -> Table.Value.Value) -> Table.ContextAggregationFn row"},{"name":"aggregationResults","comment":" The keyed counterpart of [`aggregationValue`](#aggregationValue) for a\ncolumn built with [`withAggregationFns`](#withAggregationFns): one result per\nkey. A column without the list option gives an empty `Dict`.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Dict.Dict String.String Table.Value.Value"},{"name":"aggregationValue","comment":" Aggregate one column over the rows of a row model, at the column's own\n[`withMaxAggregationDepth`](#withMaxAggregationDepth). TanStack's\n`column.getAggregationValue()`.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.Value.Value"},{"name":"aggregationValueById","comment":" One keyed aggregation result of a group row: the row, the column id, then\nthe aggregation key.\n","type":"Table.Row row -> String.String -> String.String -> Maybe.Maybe Table.Value.Value"},{"name":"aggregationValueOf","comment":" Aggregate one column over a chosen row list and depth, TanStack's\n`column.getAggregationValue({ rows, maxDepth })`. Use it for footers and\nsummaries that the grouped row model does not produce, for example the total\nof a column over every filtered row. The row model is only there to resolve\nan automatic aggregation function from the column's values; pass the core or\nfiltered model. `maxDepth` stops the descent into sub-rows; `Nothing` means\nthe column's own `maxAggregationDepth`.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> { maxDepth : Basics.Int, rows : List.List (Table.Row row) } -> Table.Value.Value"},{"name":"allColumns","comment":" Every column, group columns included, each group before its children.\n","type":"Table.Config row -> List.List (Table.Column row)"},{"name":"allColumnsRegion","comment":" Every visible leaf column, in table order, with no pin partitioning.\n","type":"Table.ColumnRegion"},{"name":"allSubRowsSelected","comment":" Every selectable descendant is selected.\n","type":"Table.SubRowSelection"},{"name":"applyCellSelectionBoundsOperations","comment":" Run ordered include and exclude operations, giving the final positive\nselection as disjoint rectangles.\n","type":"List.List ( Table.CellSelectionOperation, Table.CellSelectionBounds ) -> List.List Table.CellSelectionBounds"},{"name":"autoReset","comment":" Apply every reset TanStack's `autoReset*` scheduler would schedule for one\nchange. Call it in `update` once you have the next `State`:\n\n    newState =\n        Table.autoReset config\n            { previous = model.tableState\n            , next = nextState\n            , dataChanged = False\n            }\n\nThe page index goes back to `0` when the data, the column filters, the global\nfilter, the sorting or the grouping changed; the expanded rows collapse when\nthe data, the filters or the grouping changed (the grouped stage sits\ndownstream of filtering, so a filter change reaches it even with no grouping\nactive); and a data change clears the sorting and the cell selection.\n\nEach slice consults `autoResetAll`, then its own flag, then its default:\n[`withAutoResetPageIndex`](#withAutoResetPageIndex) defaults to on unless\n`Config.manualPagination` is set,\n[`withAutoResetExpanded`](#withAutoResetExpanded) to on unless\n`Config.manualExpanding` is set,\n[`withAutoResetSorting`](#withAutoResetSorting) to off, and\n[`withAutoResetCellSelection`](#withAutoResetCellSelection) to on.\n\nEvery reset goes to the feature default, never to a remembered initial state:\nthere is no `table.initialState` here.\n\n","type":"Table.Config row -> { previous : Table.State, next : Table.State, dataChanged : Basics.Bool } -> Table.State"},{"name":"bottomRows","comment":" The rows pinned to the bottom, in pinning-state order.\n","type":"Table.Config row -> Table.State -> Table.PinnedRowsSource row -> List.List (Table.Row row)"},{"name":"canSelectRange","comment":" Would a range from this anchor to this row be selected as a range? Both\nendpoints have to be in the display order of the pre-pagination row model\nand allow multi-selection.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> String.String -> Table.Row row -> Basics.Bool"},{"name":"cellCanSelect","comment":" Can this cell currently be selected? A column opting out wins over the\ntable option.\n","type":"Table.Config row -> Table.Cell -> Basics.Bool"},{"name":"cellColSpan","comment":" How many columns this cell spans: `1` when it does not span, and `0` when\nanother cell's column span covers it.\n","type":"Table.CellSpanIndex -> Table.Cell -> Basics.Int"},{"name":"cellDown","comment":" Move or extend one row down.\n","type":"Table.CellDirection"},{"name":"cellIsAggregated","comment":" Is this cell an aggregated one? True on a group row for a column that is\nneither the row's own grouping column nor itself grouped, and that has an\naggregation function.\n","type":"Table.Config row -> Table.RowModel row -> Table.State -> Table.Row row -> String.String -> Basics.Bool"},{"name":"cellIsCovered","comment":" Does another cell's span cover this cell? Covered cells carry no content\nof their own and must not be rendered.\n","type":"Table.CellSpanIndex -> Table.Cell -> Basics.Bool"},{"name":"cellIsFocused","comment":" Is this cell the active cell, the anchor of the most recent range? An\nexclusion's active cell is focused even though it is not selected.\n","type":"Table.State -> Table.Cell -> Basics.Bool"},{"name":"cellIsGrouped","comment":" Is this the cell of the column its group row groups by? `Cell` carries\nits row and column ids, so this takes the row and the column id.\n","type":"Table.State -> Table.Row row -> String.String -> Basics.Bool"},{"name":"cellIsPlaceholder","comment":" Is this the cell of a grouped column that is not this row's own grouping\ncolumn? Those cells render as placeholders.\n","type":"Table.State -> Table.Row row -> String.String -> Basics.Bool"},{"name":"cellIsSelected","comment":" Does this cell fall inside the final positive selection?\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> Table.Cell -> Basics.Bool"},{"name":"cellLeft","comment":" Move or extend one column left.\n","type":"Table.CellDirection"},{"name":"cellRange","comment":" A range from its two corners, taken as an inclusion:\n`cellRange anchorRowId anchorColumnId focusRowId focusColumnId`.\n","type":"String.String -> String.String -> String.String -> String.String -> Table.CellSelectionRange"},{"name":"cellRight","comment":" Move or extend one column right.\n","type":"Table.CellDirection"},{"name":"cellRowSpan","comment":" How many rows this cell spans: `1` when it does not span, and `0` when a\nspanning cell above covers it. Never render a `0`; skip the cell instead.\n","type":"Table.CellSpanIndex -> Table.Cell -> Basics.Int"},{"name":"cellSelectionBounds","comment":" The final positive selection as disjoint, inclusive display-order index\nrectangles, after every include and exclude is applied. A range whose corners\nno longer resolve is omitted rather than clamped, so it contributes nothing\nwhile staying in state.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List Table.CellSelectionBounds"},{"name":"cellSelectionColumnIds","comment":" The ids of all columns the selection intersects.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List String.String"},{"name":"cellSelectionColumnIndexes","comment":" The render-order index of every visible column id.\n","type":"Table.Config row -> Table.State -> Dict.Dict String.String Basics.Int"},{"name":"cellSelectionEdges","comment":" Which sides of this cell sit on the outer boundary of the selection. All\nfour are `False` when the cell is not selected.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> Table.Cell -> Table.CellSelectionEdges"},{"name":"cellSelectionMergeBounds","comment":" The merged-cell rectangles of the rendered rows, in the same index space.\nSelection rectangles grow to enclose these, so a merged cell is always\nentirely selected or entirely unselected.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List Table.CellSelectionBounds"},{"name":"cellSelectionRowIds","comment":" The ids of all rows the selection intersects.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List String.String"},{"name":"cellSpanIndex","comment":" Build the span index of the rows a caller renders. Pass the row model you\nrender, which is normally [`paginatedRowModel`](#paginatedRowModel); row\npinning is read off the state.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.CellSpanIndex"},{"name":"cellSpanIndexRowIds","comment":" The row ids the index was built from, in render order.\n","type":"Table.CellSpanIndex -> List.List String.String"},{"name":"cellSpanIndexRowSpans","comment":" The vertical runs per column id, indexed by render-order row position.\nOnly columns with at least one run longer than one row appear; a missing\ncolumn means every cell in it spans exactly one row.\n","type":"Table.CellSpanIndex -> Dict.Dict String.String (List.List Basics.Int)"},{"name":"cellTabIndex","comment":" `0` for the focused cell and `-1` otherwise, for a roving tabindex.\n","type":"Table.State -> Table.Cell -> Basics.Int"},{"name":"cellUp","comment":" Move or extend one row up.\n","type":"Table.CellDirection"},{"name":"centerColumnsRegion","comment":" The columns that are not pinned.\n","type":"Table.ColumnRegion"},{"name":"centerFlatHeaders","comment":" Every header of the center header rows.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"centerFooterGroups","comment":" The footer rows of the unpinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"centerHeaderGroups","comment":" The header rows of the unpinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"centerLeafColumns","comment":" The leaf columns that are not pinned, in table order.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"centerLeafHeaders","comment":" The center headers that have no sub-headers.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"centerRows","comment":" The rows of the current page that are not pinned.\n","type":"Table.State -> Table.RowModel row -> List.List (Table.Row row)"},{"name":"centerTotalSize","comment":" The width of the unpinned region.\n","type":"Table.Config row -> Table.State -> Basics.Float"},{"name":"centerVisibleCells","comment":" The visible cells of one row whose column is not pinned.\n","type":"Table.Config row -> Table.State -> Table.Row row -> List.List Table.Cell"},{"name":"centerVisibleLeafColumns","comment":" The visible leaf columns that are not pinned.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"clearCellSelection","comment":" Drop every range. This is TanStack's `resetCellSelection(table, true)`;\nthere is no separate `resetCellSelection` here because the feature default\nis the empty list.\n","type":"Table.State -> Table.State"},{"name":"clearSorting","comment":" Remove one column from `State.sorting`, leaving the others in order.\n","type":"String.String -> Table.State -> Table.State"},{"name":"column","comment":" An accessor column: an id and a way to read a cell value.\n\n    Table.column \"age\" (.age >> toFloat >> Value.Number)\n\n","type":"String.String -> (row -> Table.Value.Value) -> Table.Column row"},{"name":"columnAccessor","comment":" The accessor, when the column has one. Group and display columns have\nnone.\n","type":"Table.Column row -> Maybe.Maybe (row -> Table.Value.Value)"},{"name":"columnCanHide","comment":" Can this column be hidden? Both the column flag and `Config.enableHiding`\nhave to allow it.\n","type":"Table.Config row -> Table.Column row -> Basics.Bool"},{"name":"columnCanPin","comment":" Can this column be pinned? At least one leaf below it has to allow it and\n`Config.enableColumnPinning` has to be on.\n","type":"Table.Config row -> Table.Column row -> Basics.Bool"},{"name":"columnCanResize","comment":" Can this column be resized? Both the column's\n[`withEnableResizing`](#withEnableResizing) and the table's\n`Config.enableColumnResizing` default to `True`.\n","type":"Table.Config row -> Table.Column row -> Basics.Bool"},{"name":"columnCanSpan","comment":" Does this column take part in cell spanning? A column opting out wins\nover the table option.\n","type":"Table.Config row -> Table.Column row -> Basics.Bool"},{"name":"columnColumns","comment":" The columns nested under a group column.\n","type":"Table.Column row -> List.List (Table.Column row)"},{"name":"columnDepth","comment":" How deep the column sits in the column tree. Top level is `0`.\n","type":"Table.Column row -> Basics.Int"},{"name":"columnFlatColumns","comment":" One column and every column below it, the column itself first.\n","type":"Table.Column row -> List.List (Table.Column row)"},{"name":"columnFooter","comment":" The footer text, when one was set.\n","type":"Table.Column row -> Maybe.Maybe String.String"},{"name":"columnHeader","comment":" The header text, when one was set.\n","type":"Table.Column row -> Maybe.Maybe String.String"},{"name":"columnId","comment":" The column id.\n","type":"Table.Column row -> String.String"},{"name":"columnIndex","comment":" Where this column sits in one region of the visible leaf columns, or `-1`\nwhen it is not in that region.\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> Table.Column row -> Basics.Int"},{"name":"columnIsFirst","comment":" Is this the first visible column of the region?\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> Table.Column row -> Basics.Bool"},{"name":"columnIsLast","comment":" Is this the last visible column of the region?\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> Table.Column row -> Basics.Bool"},{"name":"columnIsPinned","comment":" Where is this column pinned? A group column reports the region of its\nfirst pinned leaf, left before right.\n","type":"Table.State -> Table.Column row -> Table.ColumnPinPosition"},{"name":"columnIsResizing","comment":" Is this column the one being dragged?\n","type":"Table.State -> Table.Column row -> Basics.Bool"},{"name":"columnIsVisible","comment":" Is this column visible? A group column is visible when any leaf below it\nis.\n","type":"Table.State -> Table.Column row -> Basics.Bool"},{"name":"columnLeafColumns","comment":" The leaf columns below one column. A leaf column returns itself.\n","type":"Table.Column row -> List.List (Table.Column row)"},{"name":"columnMaxSize","comment":" This column's maximum size in pixels.\n","type":"Table.Config row -> Table.Column row -> Basics.Float"},{"name":"columnMinSize","comment":" This column's minimum size in pixels.\n","type":"Table.Config row -> Table.Column row -> Basics.Float"},{"name":"columnParentId","comment":" The id of the group column this column sits under.\n","type":"Table.Column row -> Maybe.Maybe String.String"},{"name":"columnPinnedIndex","comment":" The column's position inside its pinned region. Unpinned columns give\n`0`, matching TanStack.\n","type":"Table.State -> Table.Column row -> Basics.Int"},{"name":"columnSize","comment":" This column's size in pixels, clamped to its minimum and maximum.\n","type":"Table.Config row -> Table.Column row -> Basics.Float"},{"name":"columnUnpinned","comment":" Not pinned. Passing this to [`pinColumn`](#pinColumn) unpins the column.\n","type":"Table.ColumnPinPosition"},{"name":"config","comment":" A configuration for a list of columns, with TanStack's defaults for every\nflag.\n\n    config [ Table.column \"firstName\" (.firstName >> Value.String) ]\n\n","type":"List.List (Table.Column row) -> Table.Config row"},{"name":"coreRowModel","comment":" The untouched row model: one row per datum, sub-rows resolved, ids\nassigned.\n","type":"Table.Config row -> Table.State -> Array.Array row -> Table.RowModel row"},{"name":"coreRowModelFromList","comment":" The `List` form of [`coreRowModel`](#coreRowModel).\n","type":"Table.Config row -> Table.State -> List.List row -> Table.RowModel row"},{"name":"defaultPinRowOptions","comment":" Pin the row alone, without its leaf rows or its ancestors.\n","type":"Table.PinRowOptions"},{"name":"defaultSelectOptions","comment":" `selectChildren` on, `deselectParents` off: TanStack's defaults.\n","type":"Table.SelectOptions"},{"name":"deselectAllRows","comment":" Clear the selection, ids of rows that cannot be selected included. This\nis TanStack's `deselectAll` option.\n","type":"Table.State -> Table.State"},{"name":"display","comment":" A display column: an id, no accessor, no children.\n","type":"String.String -> Table.Column row"},{"name":"displayIndex","comment":" A row's zero-based position in\n[`rowsInDisplayOrder`](#rowsInDisplayOrder), or `-1` when it is not there.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.Row row -> Basics.Int"},{"name":"endColumnResize","comment":" End the drag: commit the widths the last\n[`updateColumnResize`](#updateColumnResize) computed, then clear\n`State.columnResizing`. Call `updateColumnResize` first with the position of\nthe event that ended the drag, when it carries one.\n\nThis is the `mouseup`, `touchend`, or `touchcancel` half of the handler.\n\n","type":"Table.Config row -> Table.State -> Table.State"},{"name":"excludeCells","comment":" A range that subtracts its rectangle from the selection.\n","type":"Table.CellSelectionOperation"},{"name":"excludeSelection","comment":" Subtract this rectangle from the existing ranges.\n","type":"Table.CellSelectionMode"},{"name":"expandAll","comment":" Every row is expanded, whatever `State.rowSelection` holds. TanStack's\n`expanded: true`.\n","type":"Table.Expanded"},{"name":"expandCellSelectionBounds","comment":" Grow a rectangle until it fully contains every merged-cell rectangle it\ntouches.\n","type":"Table.CellSelectionBounds -> List.List Table.CellSelectionBounds -> Table.CellSelectionBounds"},{"name":"expandedIds","comment":" Only the rows with these ids are expanded.\n","type":"Set.Set String.String -> Table.Expanded"},{"name":"expandedIdsOf","comment":" The expanded row ids, or `Nothing` when every row is expanded.\n","type":"Table.Expanded -> Maybe.Maybe (Set.Set String.String)"},{"name":"expandedRowModel","comment":" Flatten the expanded branches into the row list.\n`Config.manualExpanding` skips this stage.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"extendCellSelection","comment":" Extend the active range one step, keeping its anchor fixed.\n","type":"Table.Config row -> Table.SelectionRows row -> Table.CellDirection -> Table.State -> Table.State"},{"name":"extendCellSelectionTo","comment":" Move the active range's focus corner to this cell, keeping its anchor and\nits operation. This is the state half of a shift-`mousedown` and of a drag's\n`mouseenter`. With no active range, or with\n[`withCellRangeSelection`](#withCellRangeSelection) off, it selects the cell\ninstead.\n","type":"Table.Config row -> Table.Cell -> Table.State -> Table.State"},{"name":"facetedMinMax","comment":" The smallest and largest `Number` value of one column, or `Nothing` when\nit has none. Pass the pre-filtered row model; like\n[`facetedUniqueValues`](#facetedUniqueValues) it looks through\n[`facetedRowModel`](#facetedRowModel).\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> String.String -> Maybe.Maybe ( Basics.Float, Basics.Float )"},{"name":"facetedRowModel","comment":" The rows a column's facets are computed from: the pre-filtered rows with\nevery active filter applied except that column's own, so a filter UI keeps\nshowing the values the user could switch to.\n\nPass the row model you handed to [`filteredRowModel`](#filteredRowModel).\nPassing [`globalFacetKey`](#globalFacetKey) as the column id excludes the\nglobal filter instead of a column filter.\n\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> String.String -> Table.RowModel row"},{"name":"facetedUniqueValues","comment":" Every distinct value of one column with the number of rows that carry it,\nin first-seen order. Pass the pre-filtered row model (usually the core row\nmodel); the count is taken over [`facetedRowModel`](#facetedRowModel), which\napplies every filter except this column's own. `List` cells contribute each\nitem.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> String.String -> List.List ( Table.Value.Value, Basics.Int )"},{"name":"filteredRowModel","comment":" Drop the rows that fail the column filters and the global filter.\n`Config.manualFiltering` skips this stage.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"findColumn","comment":" Find a column by id. Group columns are found too.\n","type":"Table.Config row -> String.String -> Maybe.Maybe (Table.Column row)"},{"name":"findRow","comment":" Look a row up by id.\n","type":"Table.RowModel row -> String.String -> Maybe.Maybe (Table.Row row)"},{"name":"firstPage","comment":" Go to page 0.\n","type":"Table.Config row -> Table.State -> Table.State"},{"name":"flatHeaders","comment":" Every header of every header row.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"focusedCell","comment":" The active cell: the anchor of the most recent range.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> Maybe.Maybe Table.Cell"},{"name":"footerGroups","comment":" The footer rows: the header rows bottom row first.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"getAggregationFn","comment":" The aggregation function of a column: its own, or the automatic one.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Maybe.Maybe Table.AggregationFn.AggregationFn"},{"name":"getAllCells","comment":" One cell per leaf column, in leaf column order. Hidden columns are\nincluded.\n","type":"Table.Config row -> Table.State -> Table.Row row -> List.List Table.Cell"},{"name":"getAutoAggregationFn","comment":" The aggregation function a column with no\n[`withAggregationFn`](#withAggregationFn) gets: `sum` for a numeric column,\n`extent` for a date column, none for anything else. The kind is read off the\nfirst flat row of the row model handed in.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Maybe.Maybe Table.AggregationFn.AggregationFn"},{"name":"getAutoFilterFn","comment":" The filter function `'auto'` picks for a column, from the type of its\nfirst non-null value: `includesString` for strings, `inNumberRange` for\nnumbers, `equals` for booleans, `arrIncludes` for lists, `inDateRange` for\ndates, and `weakEquals` when every value is `Null`.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.FilterFn.FilterFn"},{"name":"getAutoSortDir","comment":" The direction a column starts sorting in when nothing says otherwise: the\nfirst non-null value among the first ten rows decides, strings ascending and\neverything else descending.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.SortDir"},{"name":"getAutoSortFn","comment":" The sort function `'auto'` picks for a column. The first ten rows of the\nrow model are sampled: a date gives `datetime`, a string holding digits gives\n`alphanumeric`, any other string gives `text`, and anything else gives\n`basic`.\n\nPass the filtered row model, which is what TanStack samples.\n\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.SortFn.SortFn"},{"name":"getCanExpand","comment":" Can this row expand? [`withRowCanExpand`](#withRowCanExpand) wins,\notherwise `Config.enableExpanding` has to be on and the row needs sub-rows.\n","type":"Table.Config row -> Table.Row row -> Basics.Bool"},{"name":"getCanFilter","comment":" Can this column carry a column filter? It needs an accessor, and neither\nthe column nor `Config.enableColumnFilters` nor `Config.enableFilters` may\nhave switched filtering off.\n\nThe filtered row model does not consult this: a `State.columnFilters` entry\nfor a column that answers `False` is still applied, matching TanStack.\n\n","type":"Table.Config row -> String.String -> Basics.Bool"},{"name":"getCanGlobalFilter","comment":" Does the global filter run against this column? It needs an accessor,\n`Config.enableGlobalFilter` and `Config.enableFilters` have to be on, the\ncolumn must not opt out, and `Config.getColumnCanGlobalFilter` (whose default\nkeeps a column only when its first non-null value is a string or a number)\nhas to agree.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Basics.Bool"},{"name":"getCanGroup","comment":" Can this column be grouped? Grouping has to be enabled on the table and\non the column, and the column needs either an accessor or a\n[`withGetGroupingValue`](#withGetGroupingValue).\n","type":"Table.Config row -> String.String -> Basics.Bool"},{"name":"getCanLastPage","comment":" Is there a known last page after this one?\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getCanMultiSelect","comment":" Can this row take part in a multi-row selection?\n","type":"Table.Config row -> Table.Row row -> Basics.Bool"},{"name":"getCanMultiSort","comment":" Can this column join a multi-sort? The column's own setting wins over\n`Config.enableMultiSort`.\n","type":"Table.Config row -> String.String -> Basics.Bool"},{"name":"getCanNextPage","comment":" Is there a page after this one? An unknown page count always says yes.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getCanPinRow","comment":" Can this row be pinned?\n","type":"Table.Config row -> Table.Row row -> Basics.Bool"},{"name":"getCanPreviousPage","comment":" Is there a page before this one?\n","type":"Table.State -> Basics.Bool"},{"name":"getCanSelect","comment":" Can this row be selected?\n","type":"Table.Config row -> Table.Row row -> Basics.Bool"},{"name":"getCanSelectSubRows","comment":" Can selecting this row select its sub-rows?\n","type":"Table.Config row -> Table.Row row -> Basics.Bool"},{"name":"getCanSomeRowsExpand","comment":" Can any row of this row model expand? TanStack reads the pre-pagination\nrow model here, so controls can reflect rows that are not on this page.\n","type":"Table.Config row -> Table.RowModel row -> Basics.Bool"},{"name":"getCanSort","comment":" Can this column be sorted? It needs an accessor and both the column and\n`Config.enableSorting` have to allow it.\n","type":"Table.Config row -> String.String -> Basics.Bool"},{"name":"getColumnAfter","comment":" How far from the end of its region a column ends.\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> Table.Column row -> Basics.Float"},{"name":"getColumnSize","comment":" The rendered width of a column: the committed size from\n`State.columnSizing` when there is one, otherwise the column's own size and\nthen the configured default, clamped between `minSize` and `maxSize`.\n","type":"Table.Config row -> Table.State -> Table.Column row -> Basics.Float"},{"name":"getColumnStart","comment":" How far from the start of its region a column begins.\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> Table.Column row -> Basics.Float"},{"name":"getExpandedDepth","comment":" The deepest expanded row id, counted in `.`-separated segments.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Int"},{"name":"getFilterFn","comment":" The filter function a column filters with: the one set with\n`withFilterFn`, or the automatic choice. `Nothing` when the column does not\nexist.\n\nPass the core row model; the automatic choice samples it.\n\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Maybe.Maybe Table.FilterFn.FilterFn"},{"name":"getFilterIndex","comment":" This column's position in `State.columnFilters`, or `-1`.\n","type":"Table.State -> String.String -> Basics.Int"},{"name":"getFilterValue","comment":" This column's current filter value, when it has one.\n","type":"Table.State -> String.String -> Maybe.Maybe Table.Value.Value"},{"name":"getFirstSortDir","comment":" The direction the first click on a column sorts in: the column's\n`withSortDescFirst` wins, then `Config.sortDescFirst`, then\n[`getAutoSortDir`](#getAutoSortDir).\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.SortDir"},{"name":"getGlobalFilterFn","comment":" The filter function the global filter uses: `Config.globalFilterFn`, or\n[`globalAutoFilterFn`](#globalAutoFilterFn).\n","type":"Table.Config row -> Table.FilterFn.FilterFn"},{"name":"getGroupedIndex","comment":" Where this column sits in `State.grouping`, or `-1`.\n","type":"Table.State -> String.String -> Basics.Int"},{"name":"getHeaderSize","comment":" The width of a header: its column's size for a leaf header, the sum of\nthe sub-header widths for a parent header.\n","type":"Table.Config row -> Table.State -> Table.Header row -> Basics.Float"},{"name":"getHeaderStart","comment":" How far from the start of its header row a header begins. Pass the\nheaders of the row the header belongs to.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row) -> Table.Header row -> Basics.Float"},{"name":"getIsAllPageRowsSelected","comment":" Is every selectable row of the current page selected?\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getIsAllParentsExpanded","comment":" Is every ancestor of this row expanded? The row itself is not considered.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.Row row -> Basics.Bool"},{"name":"getIsAllRowsExpanded","comment":" Is every expandable row of this row model expanded? An empty\n`State.expanded` is `False`, and so is one whose ids match no expandable row.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getIsAllRowsSelected","comment":" Is every selectable row of the given model selected? Pass the filtered\nrow model.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getIsAllSubRowsSelected","comment":" Is this row's whole sub-tree selected?\n","type":"Table.Config row -> Table.State -> Table.Row row -> Basics.Bool"},{"name":"getIsExpanded","comment":" Is this row expanded? [`withIsRowExpanded`](#withIsRowExpanded) wins,\notherwise `State.expanded` decides.\n","type":"Table.Config row -> Table.State -> Table.Row row -> Basics.Bool"},{"name":"getIsFiltered","comment":" Does `State.columnFilters` hold an entry for this column?\n","type":"Table.State -> String.String -> Basics.Bool"},{"name":"getIsGrouped","comment":" Is this column in `State.grouping`?\n","type":"Table.State -> String.String -> Basics.Bool"},{"name":"getIsRowPinned","comment":" Where is this row pinned?\n","type":"Table.State -> Table.Row row -> Table.RowPinPosition"},{"name":"getIsRowSelected","comment":" Is this row selected?\n","type":"Table.State -> Table.Row row -> Basics.Bool"},{"name":"getIsSomePageRowsSelected","comment":" Is any row of the current page selected, or partly selected?\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Bool"},{"name":"getIsSomeRowsExpanded","comment":" Is any row expanded? `True` for [`expandAll`](#expandAll) and for a\nnon-empty [`expandedIds`](#expandedIds) set; it does not check that the ids\nstill exist in the data, which is what TanStack's `getIsSomeRowsExpanded`\ndoes too.\n","type":"Table.State -> Basics.Bool"},{"name":"getIsSomeRowsSelected","comment":" Is anything selected at all?\n","type":"Table.State -> Basics.Bool"},{"name":"getIsSomeSelected","comment":" Is part, but not all, of this row's sub-tree selected?\n","type":"Table.Config row -> Table.State -> Table.Row row -> Basics.Bool"},{"name":"getIsSorted","comment":" This column's sort direction, or `Nothing` when it is not sorted.\n","type":"Table.State -> String.String -> Maybe.Maybe Table.SortDir"},{"name":"getLeafHeaders","comment":" The descendants of a header, deepest first, with the header itself last.\n","type":"Table.Header row -> List.List (Table.Header row)"},{"name":"getLeafRows","comment":" Every descendant of a row, depth first. The row itself is not included.\n","type":"Table.Row row -> List.List (Table.Row row)"},{"name":"getNextSortingOrder","comment":" The next step of a column's sort cycle. `Nothing` means the next step\nremoves the sort, which `Config.enableSortingRemoval` and (in a multi-sort)\n`Config.enableMultiRemove` can forbid.\n","type":"Table.Config row -> Table.RowModel row -> Table.State -> String.String -> Basics.Bool -> Maybe.Maybe Table.SortDir"},{"name":"getPageCount","comment":" How many pages there are: `Config.pageCount` when it is set, otherwise\n[`getRowCount`](#getRowCount) divided by the page size, rounded up.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Basics.Int"},{"name":"getPageOptions","comment":" Every page index, `[0, 1, ...]`.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> List.List Basics.Int"},{"name":"getParentRow","comment":" The direct parent of a row, looked up in a row model.\n","type":"Table.RowModel row -> Table.Row row -> Maybe.Maybe (Table.Row row)"},{"name":"getParentRows","comment":" The ancestors of a row, from the root down to its direct parent.\n","type":"Table.RowModel row -> Table.Row row -> List.List (Table.Row row)"},{"name":"getRowCount","comment":" How many rows pagination is slicing: `Config.rowCount` when it is set,\notherwise the rows of the pre-pagination row model.\n","type":"Table.Config row -> Table.RowModel row -> Basics.Int"},{"name":"getRowPinnedIndex","comment":" The row's position among the pinned rows that are actually shown, or `-1`\nwhen it is not pinned.\n","type":"Table.Config row -> Table.State -> Table.PinnedRowsSource row -> Table.Row row -> Basics.Int"},{"name":"getSortFn","comment":" The sort function a column sorts with: the one set with `withSortFn`, or\nthe automatic choice. A column set up with `withCustomSort` compares whole\nrows and has no `SortFn`, so this reports its automatic choice while the row\nmodel uses the custom comparison.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.SortFn.SortFn"},{"name":"getSortIndex","comment":" This column's position in `State.sorting`, or `-1`.\n","type":"Table.State -> String.String -> Basics.Int"},{"name":"getUniqueValues","comment":" The values faceting and grouping use for one cell. A column with\n[`withGetUniqueValues`](#withGetUniqueValues) decides them; otherwise the cell\nvalue is wrapped in a one-item list.\n","type":"Table.Config row -> Table.Row row -> String.String -> List.List Table.Value.Value"},{"name":"getValue","comment":" Read one cell value. Unknown columns and columns without an accessor give\n`Null`.\n","type":"Table.Config row -> Table.Row row -> String.String -> Table.Value.Value"},{"name":"globalAutoFilterFn","comment":" The global filter's automatic function: `Table.FilterFn.includesString`.\n","type":"Table.FilterFn.FilterFn"},{"name":"globalFacetKey","comment":" The column id that stands for the global filter's own facet context,\n`\"__global__\"`. Passing it to [`facetedRowModel`](#facetedRowModel),\n[`facetedUniqueValues`](#facetedUniqueValues) or\n[`facetedMinMax`](#facetedMinMax) aggregates across every globally\nfilterable column.\n","type":"String.String"},{"name":"group","comment":" A group column: an id and the columns nested under it. Group columns have\nno accessor and no cells, they only produce header rows.\n","type":"String.String -> List.List (Table.Column row) -> Table.Column row"},{"name":"groupedColumnsIgnore","comment":" Leave grouped columns where they are.\n","type":"Table.GroupedColumnMode"},{"name":"groupedColumnsRemove","comment":" Drop grouped columns from the leaf column list.\n","type":"Table.GroupedColumnMode"},{"name":"groupedColumnsReorder","comment":" Move grouped columns to the front of the leaf column list.\n","type":"Table.GroupedColumnMode"},{"name":"groupedRowModel","comment":" Replace the rows with group rows. `Config.manualGrouping` skips this\nstage.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"headerCanResize","comment":" Can this header's column be resized? This is the one to ask before\nrendering a resize handle on a header.\n","type":"Table.Config row -> Table.Header row -> Basics.Bool"},{"name":"headerColSpan","comment":" How many leaf columns this header spans.\n","type":"Table.Header row -> Basics.Int"},{"name":"headerColumnId","comment":" The id of the column this header renders.\n","type":"Table.Header row -> String.String"},{"name":"headerDepth","comment":" Which header row this header belongs to, counted from `1` at the top.\n","type":"Table.Header row -> Basics.Int"},{"name":"headerGroups","comment":" The header rows of a table, top row first.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"headerId","comment":" The header id. Placeholder headers get a compound id.\n","type":"Table.Header row -> String.String"},{"name":"headerIndex","comment":" The header's position in its header row.\n","type":"Table.Header row -> Basics.Int"},{"name":"headerIsPlaceholder","comment":" Is this a filler header standing in for a column that has no group at\nthis level?\n","type":"Table.Header row -> Basics.Bool"},{"name":"headerIsResizing","comment":" Is this header's column the one being dragged?\n","type":"Table.State -> Table.Header row -> Basics.Bool"},{"name":"headerPlaceholderId","comment":" How many placeholders for the same column came before this one.\n","type":"Table.Header row -> Maybe.Maybe String.String"},{"name":"headerRowSpan","comment":" How many header rows this header spans. `0` means a header above already\ncovers this cell.\n","type":"Table.Header row -> Basics.Int"},{"name":"headerSubHeaders","comment":" The headers nested under this one.\n","type":"Table.Header row -> List.List (Table.Header row)"},{"name":"includeCells","comment":" A range that adds its rectangle to the selection.\n","type":"Table.CellSelectionOperation"},{"name":"includeSelection","comment":" Add this rectangle alongside the existing ranges.\n","type":"Table.CellSelectionMode"},{"name":"initialState","comment":" The state a table starts in: nothing sorted, nothing filtered, nothing\ngrouped, page 0 of size 10.\n","type":"Table.State"},{"name":"intersectCellSelectionBounds","comment":" The overlap of two rectangles, or `Nothing` when they are disjoint.\n","type":"Table.CellSelectionBounds -> Table.CellSelectionBounds -> Maybe.Maybe Table.CellSelectionBounds"},{"name":"isAllColumnsVisible","comment":" Is every leaf column visible?\n","type":"Table.Config row -> Table.State -> Basics.Bool"},{"name":"isSomeColumnsPinned","comment":" Is any column pinned to either edge?\n","type":"Table.State -> Basics.Bool"},{"name":"isSomeColumnsPinnedLeft","comment":" Is any column pinned to the left edge?\n","type":"Table.State -> Basics.Bool"},{"name":"isSomeColumnsPinnedRight","comment":" Is any column pinned to the right edge?\n","type":"Table.State -> Basics.Bool"},{"name":"isSomeColumnsVisible","comment":" Is at least one leaf column visible?\n","type":"Table.Config row -> Table.State -> Basics.Bool"},{"name":"isSomeRowsPinned","comment":" Is any row pinned at either edge?\n","type":"Table.State -> Basics.Bool"},{"name":"isSomeRowsPinnedBottom","comment":" Is any row pinned to the bottom?\n","type":"Table.State -> Basics.Bool"},{"name":"isSomeRowsPinnedTop","comment":" Is any row pinned to the top?\n","type":"Table.State -> Basics.Bool"},{"name":"lastPage","comment":" Go to the last page. A no-op when the page count is unknown or empty.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.State"},{"name":"leafColumns","comment":" Every leaf column, in definition order.\n","type":"Table.Config row -> List.List (Table.Column row)"},{"name":"leafHeaders","comment":" The leaf headers reachable from the top header row.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"leftColumnsRegion","comment":" The columns pinned to the left edge.\n","type":"Table.ColumnRegion"},{"name":"leftFlatHeaders","comment":" Every header of the left-pinned header rows.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"leftFooterGroups","comment":" The footer rows of the left-pinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"leftHeaderGroups","comment":" The header rows of the left-pinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"leftLeafColumns","comment":" The leaf columns pinned left, in pinning-state order.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"leftLeafHeaders","comment":" The left-pinned headers that have no sub-headers.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"leftTotalSize","comment":" The width of the left-pinned region.\n","type":"Table.Config row -> Table.State -> Basics.Float"},{"name":"leftVisibleCells","comment":" The visible cells of one row pinned left, in pinning-state order.\n","type":"Table.Config row -> Table.State -> Table.Row row -> List.List Table.Cell"},{"name":"leftVisibleLeafColumns","comment":" The visible leaf columns pinned left.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"maxSubRowDepth","comment":" The deepest row depth in a row model, counting sub-rows and group rows.\nA flat model is `0`; one level of sub-rows makes it `1`. Useful for sizing\nindentation or the header checkbox of an expanding table.\n","type":"Table.RowModel row -> Basics.Int"},{"name":"mergeAdjacentCellSelectionBounds","comment":" Fuse rectangles that share a full side into one, to a fixed point.\n","type":"List.List Table.CellSelectionBounds -> List.List Table.CellSelectionBounds"},{"name":"moveCellSelection","comment":" Move the selection one step, collapsing it to a single cell. Columns that\ncannot be selected are skipped over, and a merged cell is one stop. With\nnothing selected this selects the first selectable cell.\n","type":"Table.Config row -> Table.SelectionRows row -> Table.CellDirection -> Table.State -> Table.State"},{"name":"nextPage","comment":" Go forward one page.\n","type":"Table.Config row -> Table.State -> Table.State"},{"name":"noSubRowsSelected","comment":" No selectable descendant of this row is selected.\n","type":"Table.SubRowSelection"},{"name":"orderColumns","comment":" Put a column list in table order: `State.columnOrder` first, unlisted\ncolumns behind the listed ones, then the grouped-column rules.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row) -> List.List (Table.Column row)"},{"name":"orderGroupedColumns","comment":" Apply `Config.groupedColumnMode` to a leaf column list: move the grouped\ncolumns to the front, remove them, or leave the list alone.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row) -> List.List (Table.Column row)"},{"name":"paginatedRowModel","comment":" Keep only the rows of the current page. `Config.manualPagination` skips\nthis stage.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"pinColumn","comment":" Pin one column to an edge, or unpin it with\n[`columnUnpinned`](#columnUnpinned). A group column pins every leaf below it.\n","type":"Table.ColumnPinPosition -> Table.Column row -> Table.State -> Table.State"},{"name":"pinRow","comment":" Pin one row to an edge, or unpin it with [`rowUnpinned`](#rowUnpinned).\nPinning removes the row id from the other edge first, so a row is never in\nboth lists. Whether pinned rows are drawn from the whole data set or only\nthe current page is `Config.keepPinnedRows`, read by [`topRows`](#topRows)\nand [`bottomRows`](#bottomRows). Use [`pinRowWith`](#pinRowWith) to pin a\nrow's parents or children along with it.\n","type":"Table.RowPinPosition -> Table.Row row -> Table.State -> Table.State"},{"name":"pinRowWith","comment":" [`pinRow`](#pinRow) with the leaf rows or the ancestors of the row pinned\nalong with it. The row model is where the ancestors are looked up.\n","type":"Table.RowPinPosition -> Table.PinRowOptions -> Table.RowModel row -> Table.Row row -> Table.State -> Table.State"},{"name":"pinnedBottom","comment":" Pinned to the bottom of the table.\n","type":"Table.RowPinPosition"},{"name":"pinnedColumns","comment":" The three visible column slices at once, in render order.\n","type":"Table.Config row -> Table.State -> Table.PinnedColumns row"},{"name":"pinnedLeafColumns","comment":" The leaf columns of one region, hidden columns included.\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> List.List (Table.Column row)"},{"name":"pinnedLeft","comment":" Pinned to the left edge. TanStack's `'start'`.\n","type":"Table.ColumnPinPosition"},{"name":"pinnedRight","comment":" Pinned to the right edge. TanStack's `'end'`.\n","type":"Table.ColumnPinPosition"},{"name":"pinnedTop","comment":" Pinned to the top of the table.\n","type":"Table.RowPinPosition"},{"name":"pinnedVisibleLeafColumns","comment":" The visible leaf columns of one region.\n[`allColumnsRegion`](#allColumnsRegion) gives\n[`visibleLeafColumns`](#visibleLeafColumns) unchanged.\n","type":"Table.Config row -> Table.State -> Table.ColumnRegion -> List.List (Table.Column row)"},{"name":"preExpandedRowModel","comment":" The row model expansion runs on: the sorted one.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"preGroupedRowModel","comment":" The row model grouping runs on: the filtered one.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"prePaginationRowModel","comment":" The row model pagination slices, which is the expanded row model. The\nrow counts and page counts below all read it.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"previousPage","comment":" Go back one page, clamped at 0.\n","type":"Table.Config row -> Table.State -> Table.State"},{"name":"replaceSelection","comment":" Replace the whole selection with this rectangle.\n","type":"Table.CellSelectionMode"},{"name":"resetColumnFilters","comment":" Clear every column filter.\n","type":"Table.State -> Table.State"},{"name":"resetColumnOrder","comment":" Drop `State.columnOrder`, restoring definition order.\n","type":"Table.State -> Table.State"},{"name":"resetColumnPinning","comment":" Unpin every column.\n","type":"Table.State -> Table.State"},{"name":"resetColumnResizing","comment":" Drop the transient slice back to \"no drag in progress\". Ports\n`table.resetHeaderSizeInfo(true)`.\n","type":"Table.State -> Table.State"},{"name":"resetColumnSize","comment":" Drop one column's committed size, leaving the other columns alone.\n","type":"String.String -> Table.State -> Table.State"},{"name":"resetColumnSizing","comment":" Drop every committed size.\n","type":"Table.State -> Table.State"},{"name":"resetColumnVisibility","comment":" Clear the visibility map, which shows every column again.\n","type":"Table.State -> Table.State"},{"name":"resetExpanded","comment":" Collapse everything: `State.expanded` back to no ids.\n","type":"Table.State -> Table.State"},{"name":"resetGlobalFilter","comment":" Clear the global filter.\n","type":"Table.State -> Table.State"},{"name":"resetGrouping","comment":" Empty `State.grouping`.\n","type":"Table.State -> Table.State"},{"name":"resetPageIndex","comment":" Back to page 0.\n","type":"Table.Config row -> Table.State -> Table.State"},{"name":"resetPageSize","comment":" Back to a page size of 10.\n","type":"Table.State -> Table.State"},{"name":"resetPagination","comment":" Back to page 0 with a page size of 10.\n","type":"Table.State -> Table.State"},{"name":"resetRowPinning","comment":" Unpin every row.\n","type":"Table.State -> Table.State"},{"name":"resetRowSelection","comment":" Clear the selection.\n","type":"Table.State -> Table.State"},{"name":"resetSorting","comment":" Clear every sort.\n","type":"Table.State -> Table.State"},{"name":"resizeLtr","comment":" A left-to-right layout: dragging right widens the column. TanStack's\n`'ltr'`.\n","type":"Table.ColumnResizeDirection"},{"name":"resizeOnChange","comment":" Commit the new widths on every pointer move.\n","type":"Table.ColumnResizeMode"},{"name":"resizeOnEnd","comment":" Commit the new widths only when the drag ends. Until then the drag shows\nin `State.columnResizing.deltaOffset`, which is what a preview indicator\nrenders from.\n","type":"Table.ColumnResizeMode"},{"name":"resizeRtl","comment":" A right-to-left layout: dragging left widens the column. TanStack's\n`'rtl'`.\n","type":"Table.ColumnResizeDirection"},{"name":"rightColumnsRegion","comment":" The columns pinned to the right edge.\n","type":"Table.ColumnRegion"},{"name":"rightFlatHeaders","comment":" Every header of the right-pinned header rows.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"rightFooterGroups","comment":" The footer rows of the right-pinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"rightHeaderGroups","comment":" The header rows of the right-pinned columns.\n","type":"Table.Config row -> Table.State -> List.List (Table.HeaderGroup row)"},{"name":"rightLeafColumns","comment":" The leaf columns pinned right, in pinning-state order.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"rightLeafHeaders","comment":" The right-pinned headers that have no sub-headers.\n","type":"Table.Config row -> Table.State -> List.List (Table.Header row)"},{"name":"rightTotalSize","comment":" The width of the right-pinned region.\n","type":"Table.Config row -> Table.State -> Basics.Float"},{"name":"rightVisibleCells","comment":" The visible cells of one row pinned right, in pinning-state order.\n","type":"Table.Config row -> Table.State -> Table.Row row -> List.List Table.Cell"},{"name":"rightVisibleLeafColumns","comment":" The visible leaf columns pinned right.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"rowAggregatedValues","comment":" The aggregated values of a group row, keyed by column id.\n","type":"Table.Row row -> Dict.Dict String.String Table.Value.Value"},{"name":"rowAggregationResults","comment":" The keyed aggregation results a group row carries for one column, the\ncounterpart of [`rowAggregatedValues`](#rowAggregatedValues) for a column\nbuilt with [`withAggregationFns`](#withAggregationFns).\n","type":"Table.Row row -> String.String -> Dict.Dict String.String Table.Value.Value"},{"name":"rowColumnFilters","comment":" Whether the row passed each filter [`filteredRowModel`](#filteredRowModel)\nevaluated, keyed by column id, plus [`globalFacetKey`](#globalFacetKey) for\nthe global filter. Empty on every row model but a filtered one.\n","type":"Table.Row row -> Dict.Dict String.String Basics.Bool"},{"name":"rowColumnFiltersMeta","comment":" The meta each filter recorded for the row, keyed by the column id it was\nevaluated for. A filter fn records meta when it was built with\n[`Table.FilterFn.withMeta`](Table-FilterFn#withMeta), a column when it was\nbuilt with [`withCustomFilterMeta`](#withCustomFilterMeta).\n","type":"Table.Row row -> Dict.Dict String.String Table.Value.Value"},{"name":"rowDepth","comment":" How deep the row sits in the row tree. Root rows are `0`.\n","type":"Table.Row row -> Basics.Int"},{"name":"rowFilterMeta","comment":" The meta one column's filter recorded for the row. This is the rank a\nfuzzy filter stores and a custom sort then orders by.\n","type":"Table.Row row -> String.String -> Maybe.Maybe Table.Value.Value"},{"name":"rowGroupingColumnId","comment":" The column a group row groups by, when the row is a group row.\n","type":"Table.Row row -> Maybe.Maybe String.String"},{"name":"rowGroupingValue","comment":" The value a group row groups by.\n","type":"Table.Row row -> Table.Value.Value"},{"name":"rowGroupingValueFor","comment":" The value this row groups by for one column:\n[`withGetGroupingValue`](#withGetGroupingValue) when the column has one, the\ncell value otherwise.\n","type":"Table.Config row -> Table.Row row -> String.String -> Table.Value.Value"},{"name":"rowId","comment":" The row id.\n","type":"Table.Row row -> String.String"},{"name":"rowIndex","comment":" The row's index among its siblings.\n","type":"Table.Row row -> Basics.Int"},{"name":"rowIsGrouped","comment":" Was this row built by the grouped row model?\n","type":"Table.Row row -> Basics.Bool"},{"name":"rowLeafRows","comment":" The leaf rows a group row was built from. Empty for ordinary rows.\n","type":"Table.Row row -> List.List (Table.Row row)"},{"name":"rowOriginal","comment":" The original datum this row was built from.\n","type":"Table.Row row -> row"},{"name":"rowOriginalSubRows","comment":" The raw children `Config.getSubRows` returned for this row.\n","type":"Table.Row row -> List.List row"},{"name":"rowParentId","comment":" The id of the row's parent, when it has one.\n","type":"Table.Row row -> Maybe.Maybe String.String"},{"name":"rowSubRows","comment":" The row's children.\n","type":"Table.Row row -> List.List (Table.Row row)"},{"name":"rowUnpinned","comment":" Not pinned. Passing this to [`pinRow`](#pinRow) unpins the row.\n","type":"Table.RowPinPosition"},{"name":"rows","comment":" The whole pipeline: core, filtered, grouped, sorted, expanded,\npaginated, in that order.\n\nA `manual` flag on the config skips its stage and passes the row model\nthrough unchanged.\n\n","type":"Table.Config row -> Table.State -> Array.Array row -> Table.RowModel row"},{"name":"rowsFromList","comment":" The `List` form of [`rows`](#rows).\n","type":"Table.Config row -> Table.State -> List.List row -> Table.RowModel row"},{"name":"rowsInDisplayOrder","comment":" The rows a caller renders, in order. With\n`Config.paginateExpandedRows = False` the expanded descendants that the\npre-pagination row model does not carry are inserted here.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> List.List (Table.Row row)"},{"name":"selectAllCells","comment":" Select every selectable cell as one range.\n","type":"Table.Config row -> Table.SelectionRows row -> Table.State -> Table.State"},{"name":"selectCell","comment":" Start a selection at one cell, replacing whatever was selected. This is\nthe state half of the `mousedown` handler with no modifier key.\n","type":"Table.Config row -> Table.Cell -> Table.State -> Table.State"},{"name":"selectCellRange","comment":" Select a rectangle, replacing the selection.\n","type":"Table.CellSelectionRange -> Table.State -> Table.State"},{"name":"selectCellRangeWith","comment":" Select a rectangle with replace, include, or exclude semantics.\n","type":"Table.CellSelectionMode -> Table.CellSelectionRange -> Table.State -> Table.State"},{"name":"selectRange","comment":" Select or deselect every row between an anchor id and this row, in\ndisplay order. Pass the pre-pagination row model (the expanded row model):\nlike TanStack's `getRowsInDisplayOrder`, the range ignores the current page\nand honours `Config.paginateExpandedRows`, so a shift-click can span pages.\nFalls back to an ordinary toggle when the range is not usable, which is what\nthe shift-click handler does.\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.Row row -> Basics.Bool -> Table.State -> Table.State"},{"name":"selectRangeWith","comment":" [`selectRange`](#selectRange) with explicit\n[`SelectOptions`](#SelectOptions).\n","type":"Table.Config row -> Table.SelectOptions -> Table.RowModel row -> String.String -> Table.Row row -> Basics.Bool -> Table.State -> Table.State"},{"name":"selectedCellCount","comment":" How many cells are selected. A merged cell counts once.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> Basics.Int"},{"name":"selectedCellIds","comment":" The unique ids of all selected cells, in row-major order. Cells another\ncell's span covers are skipped, so the ids match what renders.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List String.String"},{"name":"selectedCellRangesData","comment":" Each final positive region's values as a row-major grid, indexed as\nregion, then row, then column. Covered cells keep their values so the grid\nstays rectangular; serializing it is the caller's job.\n","type":"Table.Config row -> Table.State -> Table.SelectionRows row -> List.List (List.List (List.List Table.Value.Value))"},{"name":"selectedRowIds","comment":" The selected row ids.\n","type":"Table.State -> List.List String.String"},{"name":"selectedRowModel","comment":" Keep only the selected rows of a row model. Selected descendants of\nunselected parents stay in `flatRows` and `rowsById` but not in `rows`,\nexactly like TanStack's `selectRowsFn`. TanStack's three selected row models\nare this function over the core, the filtered, and the sorted row model.\n","type":"Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"setCellSelection","comment":" Replace the whole `cellSelection` slice.\n","type":"List.List Table.CellSelectionRange -> Table.State -> Table.State"},{"name":"setColumnFilter","comment":" Set one column's filter value: replaced in place when the column already\nhas one, appended otherwise, and removed when\n[`shouldAutoRemoveFilter`](#shouldAutoRemoveFilter) says the value is blank.\n\nPass the core row model: a column without an explicit filter function picks\nits automatic one from the first values, and that choice decides the\nauto-remove rule.\n\n","type":"Table.Config row -> Table.RowModel row -> String.String -> Table.Value.Value -> Table.State -> Table.State"},{"name":"setColumnFilters","comment":" Replace `State.columnFilters` wholesale, dropping the entries of known\ncolumns whose value should auto-remove. Pass the core row model, as for\n[`setColumnFilter`](#setColumnFilter).\n","type":"Table.Config row -> Table.RowModel row -> List.List Table.ColumnFilter -> Table.State -> Table.State"},{"name":"setColumnOrder","comment":" Replace `State.columnOrder`.\n","type":"List.List String.String -> Table.State -> Table.State"},{"name":"setColumnPinning","comment":" Replace the column pinning state.\n","type":"Table.ColumnPinning -> Table.State -> Table.State"},{"name":"setColumnResizing","comment":" Replace the whole transient slice. Ports `table.setColumnResizing`.\n","type":"Table.ColumnResizingState -> Table.State -> Table.State"},{"name":"setColumnSize","comment":" Commit one column's size.\n","type":"String.String -> Basics.Float -> Table.State -> Table.State"},{"name":"setColumnSizing","comment":" Replace the whole sizing map.\n","type":"Dict.Dict String.String Basics.Float -> Table.State -> Table.State"},{"name":"setColumnVisibility","comment":" Replace the whole visibility map.\n","type":"Dict.Dict String.String Basics.Bool -> Table.State -> Table.State"},{"name":"setExpanded","comment":" Replace `State.expanded`.\n","type":"Table.Expanded -> Table.State -> Table.State"},{"name":"setFocusedCell","comment":" Collapse the selection to a single cell at the given coordinates.\n","type":"String.String -> String.String -> Table.State -> Table.State"},{"name":"setGlobalFilter","comment":" Set the global filter value.\n","type":"Table.Value.Value -> Table.State -> Table.State"},{"name":"setGrouping","comment":" Replace `State.grouping`.\n","type":"List.List String.String -> Table.State -> Table.State"},{"name":"setPage","comment":" Go to a page, clamped to `[0, Config.pageCount - 1]` when\n`Config.pageCount` is set. A `Config.pageCount` of `Just -1` means the count\nis unknown and clamps nothing.\n","type":"Table.Config row -> Basics.Int -> Table.State -> Table.State"},{"name":"setPageSize","comment":" Change the page size, at least `1`. The page index moves so the row that\nwas at the top of the page stays in view.\n","type":"Basics.Int -> Table.State -> Table.State"},{"name":"setPagination","comment":" Replace `State.pagination`.\n","type":"Table.Pagination -> Table.State -> Table.State"},{"name":"setRowPinning","comment":" Replace the row pinning state.\n","type":"Table.RowPinning -> Table.State -> Table.State"},{"name":"setRowSelection","comment":" Replace the selection.\n","type":"Set.Set String.String -> Table.State -> Table.State"},{"name":"setSorting","comment":" Replace `State.sorting`.\n","type":"List.List Table.SortColumn -> Table.State -> Table.State"},{"name":"shouldAutoRemoveFilter","comment":" Should a filter value be dropped from state instead of stored? A filter\nfunction's own rule wins; without one, `Null` and the empty string are\ndropped.\n","type":"Maybe.Maybe Table.FilterFn.FilterFn -> Table.Value.Value -> Basics.Bool"},{"name":"someSubRowsSelected","comment":" Some, but not all, selectable descendants are selected.\n","type":"Table.SubRowSelection"},{"name":"sortAsc","comment":" Ascending.\n","type":"Table.SortDir"},{"name":"sortDesc","comment":" Descending.\n","type":"Table.SortDir"},{"name":"sortNullsAsMinusOne","comment":" Sort `Null` cell values as if they compared `-1` against anything else,\nTanStack's `sortUndefined: -1`.\n","type":"Table.SortUndefined"},{"name":"sortNullsAsPlusOne","comment":" Sort `Null` cell values as if they compared `1` against anything else,\nTanStack's `sortUndefined: 1`.\n","type":"Table.SortUndefined"},{"name":"sortNullsFirst","comment":" Sort `Null` cell values before every other value.\n","type":"Table.SortUndefined"},{"name":"sortNullsLast","comment":" Sort `Null` cell values after every other value. This is the default.\n","type":"Table.SortUndefined"},{"name":"sortedRowModel","comment":" Sort every level of the row tree. `Config.manualSorting` skips this\nstage.\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"spanAllColumns","comment":" The stand-in for `Infinity` in a [`withSpanColumns`](#withSpanColumns)\ncallback: \"the rest of my region\".\n","type":"Basics.Int"},{"name":"startColumnResize","comment":" Begin a drag on a header at the pointer's `clientX`. Records where the\npointer started, how wide the header was, and how wide every leaf header\nunder it was. A column that cannot be resized leaves the state alone.\n\nThis is the `mousedown` or `touchstart` half of TanStack's\n`header.getResizeHandler()`.\n\n","type":"Table.Config row -> Table.State -> Table.Header row -> Basics.Float -> Table.State"},{"name":"subRowSelection","comment":" How much of this row's sub-tree is selected.\n","type":"Table.Config row -> Table.State -> Table.Row row -> Table.SubRowSelection"},{"name":"subtractCellSelectionBounds","comment":" The parts of the first rectangle the second does not cover, as up to four\ndisjoint rectangles.\n","type":"Table.CellSelectionBounds -> Table.CellSelectionBounds -> List.List Table.CellSelectionBounds"},{"name":"taggedRowModel","comment":" The pre-filtered row model with the filter flags and the filter meta\nwritten onto every row, dropping nothing.\n\nTanStack writes both maps onto the rows of `getPreFilteredRowModel()` in\nplace while `getFilteredRowModel()` runs, so they can be read there for rows\nthat did not survive. Rows are immutable here, so this is the function that\nhands those rows back. `Config.manualFiltering` skips it, exactly as it skips\n[`filteredRowModel`](#filteredRowModel).\n\n","type":"Table.Config row -> Table.State -> Table.RowModel row -> Table.RowModel row"},{"name":"toggleAllColumnsVisible","comment":" Show or hide every leaf column; `Nothing` flips the current state.\nColumns that cannot hide stay visible.\n","type":"Table.Config row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleAllPageRowsSelected","comment":" Select or deselect every row of the current page. Pass the paginated row\nmodel.\n","type":"Table.Config row -> Table.RowModel row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleAllRowsExpanded","comment":" Expand or collapse every row. `Nothing` toggles on\n[`getIsAllRowsExpanded`](#getIsAllRowsExpanded).\n","type":"Table.Config row -> Table.RowModel row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleAllRowsSelected","comment":" Select or deselect every row of the given model; `Nothing` flips on the\ncurrent all-selected state. Pass the filtered row model, which is what\nTanStack's pre-grouped model is.\n","type":"Table.Config row -> Table.RowModel row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleCellSelection","comment":" Add a rectangle at this cell alongside the existing ranges, subtracting\ninstead when the cell is already selected. This is the state half of a ctrl-\nor meta-`mousedown`. With\n[`withMultiCellRangeSelection`](#withMultiCellRangeSelection) off, it selects\nthe cell instead.\n","type":"Table.Config row -> Table.SelectionRows row -> Table.Cell -> Table.State -> Table.State"},{"name":"toggleColumnVisibility","comment":" Show or hide one column; `Nothing` flips it. A group column writes every\nhideable leaf below it, because visibility is keyed by leaf column id.\n","type":"Table.Config row -> Table.Column row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleExpanded","comment":" Expand or collapse one row. `Nothing` toggles it. Expanding a row that\ncannot expand and any request that matches the current state are no-ops;\ncollapsing always applies, so a stale id can be cleaned up.\n\nThe row model materialises [`expandAll`](#expandAll) into the ids of the rows\nthat can expand before the change lands. Pass the pre-expanded row model\n(the sorted row model, or whatever [`preExpandedRowModel`](#preExpandedRowModel)\ngives you), so group rows are included when grouping is on.\n\n","type":"Table.Config row -> Table.RowModel row -> Table.Row row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleGrouping","comment":" Add this column to `State.grouping`, or drop it and keep the rest in\norder. TanStack's `column_toggleGrouping` does not check\n[`getCanGroup`](#getCanGroup) either; its click handler does.\n","type":"String.String -> Table.State -> Table.State"},{"name":"toggleRowSelected","comment":" Select or deselect one row; `Nothing` flips it. Sub-rows follow along.\nThe row model is only read for the parent chain, so the core row model is\nthe usual argument.\n","type":"Table.Config row -> Table.RowModel row -> Table.Row row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleRowSelectedWith","comment":" [`toggleRowSelected`](#toggleRowSelected) with explicit\n[`SelectOptions`](#SelectOptions).\n","type":"Table.Config row -> Table.SelectOptions -> Table.RowModel row -> Table.Row row -> Maybe.Maybe Basics.Bool -> Table.State -> Table.State"},{"name":"toggleSort","comment":" Step a column's sort: add it, replace the sort with it, flip its\ndirection, or remove it.\n\n`desc = Just d` sets the direction outright instead of stepping the cycle.\n`multi = True` asks to add to the existing sort rather than replace it, which\nhappens only when [`getCanMultiSort`](#getCanMultiSort) allows it;\n`Config.maxMultiSortColCount` caps how many columns a multi-sort keeps.\n\nThe row model is the pre-sorted one (the grouped row model, or the core\nrow model when nothing is grouped or filtered): the first sort direction of\na column without `sortDescFirst` depends on its values.\n\n","type":"Table.Config row -> Table.RowModel row -> String.String -> { desc : Maybe.Maybe Basics.Bool, multi : Basics.Bool } -> Table.State -> Table.State"},{"name":"topRows","comment":" The rows pinned to the top, in pinning-state order.\n","type":"Table.Config row -> Table.State -> Table.PinnedRowsSource row -> List.List (Table.Row row)"},{"name":"totalSize","comment":" The width of the whole table: the sum of the top header row.\n","type":"Table.Config row -> Table.State -> Basics.Float"},{"name":"unlimitedPageSize","comment":" The page size that puts every row on one page. Elm has no `Infinity` for\n`Int`, so this is `Number.MAX_SAFE_INTEGER` where TanStack writes `Infinity`.\n","type":"Basics.Int"},{"name":"updateColumnResize","comment":" Move the drag to a new `clientX`. Writes `deltaOffset` and\n`deltaPercentage`, and in [`resizeOnChange`](#resizeOnChange) mode commits the\nnew widths to `State.columnSizing`. With no drag in progress nothing happens.\n\nThis is the `mousemove` or `touchmove` half of the handler.\n\n","type":"Table.Config row -> Basics.Float -> Table.State -> Table.State"},{"name":"visibleCells","comment":" The cells of one row whose column is visible: left-pinned first, then the\nunpinned cells in table order, then the right-pinned ones.\n","type":"Table.Config row -> Table.State -> Table.Row row -> List.List Table.Cell"},{"name":"visibleCellsByColumnId","comment":" The visible cells of one row keyed by column id.\n","type":"Table.Config row -> Table.State -> Table.Row row -> Dict.Dict String.String Table.Cell"},{"name":"visibleFlatColumns","comment":" Every column of the table, group columns included, minus the hidden ones.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"visibleLeafColumns","comment":" The leaf columns a table renders: `State.columnOrder` applied, hidden\ncolumns dropped.\n","type":"Table.Config row -> Table.State -> List.List (Table.Column row)"},{"name":"withAggregationFn","comment":" Aggregate this column's values on group rows.\n","type":"Table.AggregationFn.AggregationFn -> Table.Column row -> Table.Column row"},{"name":"withAggregationFns","comment":" Aggregate this column with several aggregation functions at once, each\nunder its own key: TanStack's `aggregationFn: ['count', 'mean', { id: 'range',\naggregationFn: 'extent' }]`.\n\nThe result is a keyed `Dict`, not one `Value`, so it is read back with\n[`aggregationResults`](#aggregationResults) and\n[`rowAggregationResults`](#rowAggregationResults) rather than with\n[`getValue`](#getValue), which gives `Null` for such a column. A duplicated\nkey keeps its entry and gives `Null`, which is TanStack warning and keeping\nthe key with `undefined`.\n\n","type":"List.List ( String.String, Table.AggregationFn.AggregationFn ) -> Table.Column row -> Table.Column row"},{"name":"withAutoResetAll","comment":" Force every auto-reset on or off, overriding each individual flag. Ports\n`autoResetAll`.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withAutoResetCellSelection","comment":" Override whether [`autoReset`](#autoReset) clears the cell selection on a\ndata change. The default is on. Ports `autoResetCellSelection`.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withAutoResetExpanded","comment":" Override whether [`autoReset`](#autoReset) collapses the expanded rows.\nThe default is on unless `Config.manualExpanding` is set. Ports\n`autoResetExpanded`.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withAutoResetPageIndex","comment":" Override whether [`autoReset`](#autoReset) returns to page 0. The default\nis on unless `Config.manualPagination` is set. Ports `autoResetPageIndex`.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withAutoResetSorting","comment":" Override whether [`autoReset`](#autoReset) clears the sorting on a data\nchange. The default is off, as in TanStack. Ports `autoResetSorting`.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withCellRangeSelection","comment":" Allow or forbid extending a cell selection into a range, which is what\nshift-click and drag do.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withCellSelection","comment":" Allow or forbid cell selection for the whole table.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withCellSelectionWhen","comment":" Decide per cell whether it can be selected. The predicate replaces the\nboolean, exactly like TanStack's `enableCellSelection` in its function form.\n","type":"(Table.Cell -> Basics.Bool) -> Table.Config row -> Table.Config row"},{"name":"withCellSpanning","comment":" Allow or forbid cell spanning for the whole table. `False` makes every\ncell report a span of `1` and builds no span index.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withContextAggregationFn","comment":" Aggregate this column with a function of the whole\n[`AggregationContext`](#AggregationContext). It takes precedence over\n[`withAggregationFn`](#withAggregationFn).\n","type":"Table.ContextAggregationFn row -> Table.Column row -> Table.Column row"},{"name":"withCustomFilter","comment":" Filter this column with a predicate on whole rows.\n","type":"(Table.Row row -> Table.Value.Value -> Basics.Bool) -> Table.Column row -> Table.Column row"},{"name":"withCustomFilterMeta","comment":" Filter this column with a predicate on whole rows that also produces the\nmeta the filtered row model records for the row, TanStack's `addMeta`\ncallback turned into a return value.\n\n[`withCustomFilter`](#withCustomFilter) is unchanged and records no meta;\nwhen a column carries both, this one wins.\n\n","type":"(Table.Row row -> Table.Value.Value -> ( Basics.Bool, Maybe.Maybe Table.Value.Value )) -> Table.Column row -> Table.Column row"},{"name":"withCustomSort","comment":" Sort this column with a comparison on whole rows.\n","type":"(Table.Row row -> Table.Row row -> Basics.Order) -> Table.Column row -> Table.Column row"},{"name":"withDefaultColumn","comment":" Override the default column sizing (`150`, `20`, `9007199254740991`).\n","type":"Table.SizeDefaults -> Table.Config row -> Table.Config row"},{"name":"withEnableCellSelection","comment":" Allow or forbid selecting the cells of one column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableCellSpanning","comment":" Turn one column off for cell spanning even when the table allows it.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableColumnFilter","comment":" Allow or forbid a column filter on this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableGlobalFilter","comment":" Include or exclude this column from the global filter.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableGrouping","comment":" Allow or forbid grouping by this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableHiding","comment":" Allow or forbid hiding this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableMultiSort","comment":" Allow or forbid this column in a multi-sort.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnablePinning","comment":" Allow or forbid pinning this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableResizing","comment":" Allow or forbid resizing one column. Ports the column-level\n`enableResizing`.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withEnableSorting","comment":" Allow or forbid sorting on this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withFilterFn","comment":" Filter this column with a built-in filter function.\n","type":"Table.FilterFn.FilterFn -> Table.Column row -> Table.Column row"},{"name":"withFooter","comment":" Set the footer text.\n","type":"String.String -> Table.Column row -> Table.Column row"},{"name":"withGetAggregationValue","comment":" Supply this column's aggregation value instead of computing it, TanStack's\n`getAggregationValue` column option. It short-circuits\n[`aggregationValue`](#aggregationValue) and\n[`aggregationValueOf`](#aggregationValueOf), before\n[`withManualAggregation`](#withManualAggregation) and before any aggregation\nfunction, and like TanStack it does not touch the grouped row model, which\naggregates through the column's aggregation functions.\n\nTanStack lets the provider decline by returning `undefined` and fall back to\nthe local aggregation; there is no counterpart for that here, since a\nprovider that returns `Null` is TanStack's handled `{ value: undefined }`.\n\n","type":"(Table.AggregationContext row -> Table.Value.Value) -> Table.Column row -> Table.Column row"},{"name":"withGetGroupingValue","comment":" Read the value this column groups by, when it differs from the accessor.\nThe second argument is the row's index, mirroring TanStack's\n`getGroupingValue(originalRow, index, row)`.\n","type":"(row -> Basics.Int -> Table.Value.Value) -> Table.Column row -> Table.Column row"},{"name":"withGetRowId","comment":" Give rows stable ids. The function receives the datum, its index among\nits siblings, and its parent's row id.\n\nWithout it, root rows are `\"0\"`, `\"1\"`, and children are `\"0.1\"`, `\"0.2\"`.\n\n","type":"(row -> Basics.Int -> Maybe.Maybe String.String -> String.String) -> Table.Config row -> Table.Config row"},{"name":"withGetUniqueValues","comment":" Read the faceting values of a row, when one cell holds several.\n","type":"(row -> List.List Table.Value.Value) -> Table.Column row -> Table.Column row"},{"name":"withGlobalFilterFn","comment":" Set the filter function the global filter uses.\n","type":"Table.FilterFn.FilterFn -> Table.Config row -> Table.Config row"},{"name":"withHeader","comment":" Set the header text.\n","type":"String.String -> Table.Column row -> Table.Column row"},{"name":"withInvertSorting","comment":" Invert the sort direction of this column.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withIsRowExpanded","comment":" Set a per-row override for \"is this row expanded?\", TanStack's\n`getIsRowExpanded`. It wins over `State.expanded` outright.\n","type":"(Table.Row row -> Basics.Bool) -> Table.Config row -> Table.Config row"},{"name":"withManualAggregation","comment":" Hand every column's aggregation value to the caller:\n[`aggregationValue`](#aggregationValue) and\n[`aggregationValueOf`](#aggregationValueOf) give `Null` for a column without\n[`withGetAggregationValue`](#withGetAggregationValue). Ports the\n`manualAggregation` table option; like TanStack's it leaves the grouped row\nmodel alone.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withMaxAggregationDepth","comment":" How far below an aggregated row its aggregation looks for values.\n`0`, the default, aggregates the rows themselves; `1` aggregates their\nchildren. TanStack's `maxAggregationDepth`.\n","type":"Basics.Int -> Table.Column row -> Table.Column row"},{"name":"withMaxSize","comment":" Set this column's maximum size in pixels.\n","type":"Basics.Float -> Table.Column row -> Table.Column row"},{"name":"withMinSize","comment":" Set this column's minimum size in pixels.\n","type":"Basics.Float -> Table.Column row -> Table.Column row"},{"name":"withMultiCellRangeSelection","comment":" Allow or forbid adding and subtracting further rectangles, which is what\nctrl-click and meta-click do.\n","type":"Basics.Bool -> Table.Config row -> Table.Config row"},{"name":"withRowCanExpand","comment":" Set a per-row override for \"can this row expand?\", TanStack's\n`getRowCanExpand`. It wins over `Config.enableExpanding` and over the\n\"has sub-rows\" rule.\n","type":"(Table.Row row -> Basics.Bool) -> Table.Config row -> Table.Config row"},{"name":"withRowSelection","comment":" Decide per row whether it can be selected.\n","type":"(Table.Row row -> Basics.Bool) -> Table.Config row -> Table.Config row"},{"name":"withSize","comment":" Set this column's size in pixels.\n","type":"Basics.Float -> Table.Column row -> Table.Column row"},{"name":"withSortDescFirst","comment":" Make the first click on this column sort descending.\n","type":"Basics.Bool -> Table.Column row -> Table.Column row"},{"name":"withSortFn","comment":" Sort this column with a built-in sort function.\n","type":"Table.SortFn.SortFn -> Table.Column row -> Table.Column row"},{"name":"withSortUndefined","comment":" Decide where `Null` values land when this column is sorted.\n","type":"Table.SortUndefined -> Table.Column row -> Table.Column row"},{"name":"withSpanColumns","comment":" Make this column's cell span that many columns in the given row, counted\nin render order. A span is clamped to the end of the cell's pinned region, so\nit never crosses the left, center, or right boundary.\n","type":"(Table.Row row -> Basics.Int) -> Table.Column row -> Table.Column row"},{"name":"withSpanRows","comment":" Merge adjacent rows whose value for this column is equal into one\nvertically spanning cell. `Null` never merges under this comparison; use\n[`withSpanRowsWhen`](#withSpanRowsWhen) to opt in.\n","type":"Table.Column row -> Table.Column row"},{"name":"withSpanRowsWhen","comment":" Decide per candidate row whether it joins the vertical run anchored at\n`anchorRow`.\n","type":"(Table.RowSpanContext row -> Basics.Bool) -> Table.Column row -> Table.Column row"},{"name":"withSubRows","comment":" Tell the core row model how to reach a row's children.\n","type":"(row -> List.List row) -> Table.Config row -> Table.Config row"}],"binops":[]},{"name":"Table.AggregationFn","comment":" Built-in aggregation functions, ported from\n`row-aggregation/aggregationFns.ts`.\n\nAn `AggregationFn` folds the values of a column over a group's leaf rows.\nSome also know how to `merge` the results of child groups, which lets nested\ngroups avoid re-reading every leaf.\n\n\n# Type\n\n@docs AggregationFn\n\n\n# Built-ins\n\n@docs sum, min, max, extent, mean, median, unique, uniqueCount, count, first, last\n\n\n# Building your own\n\n@docs custom, withMerge\n\n\n# Applying\n\n@docs aggregate, merge\n\n","unions":[{"name":"AggregationFn","comment":" A fold over leaf values plus an optional merge of child results.\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"aggregate","comment":" Fold leaf values.\n","type":"Table.AggregationFn.AggregationFn -> List.List Table.Value.Value -> Table.Value.Value"},{"name":"count","comment":" Number of rows.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"custom","comment":" Build an aggregation from a fold over leaf values.\n","type":"(List.List Table.Value.Value -> Table.Value.Value) -> Table.AggregationFn.AggregationFn"},{"name":"extent","comment":" `List [ min, max ]`, or `List [ Null, Null ]` when there is no value of a\ncomparable kind.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"first","comment":" First row's value, `Null` for no rows.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"last","comment":" Last row's value, `Null` for no rows.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"max","comment":" Largest `Number` or `Date`; `Null` when there is none.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"mean","comment":" Arithmetic mean of numeric values; `Null` when there is none.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"median","comment":" Median of `Number` values; `Null` when there is none.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"merge","comment":" The merge step, if the aggregation has one.\n","type":"Table.AggregationFn.AggregationFn -> Maybe.Maybe (List.List Table.Value.Value -> Table.Value.Value)"},{"name":"min","comment":" Smallest `Number` or `Date`; `Null` when there is none.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"sum","comment":" Sum of `Number` values; other values count as zero.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"unique","comment":" Distinct values in first-seen order, as a `List`.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"uniqueCount","comment":" Number of distinct values.\n","type":"Table.AggregationFn.AggregationFn"},{"name":"withMerge","comment":" Add a merge step for child-group results.\n","type":"(List.List Table.Value.Value -> Table.Value.Value) -> Table.AggregationFn.AggregationFn -> Table.AggregationFn.AggregationFn"}],"binops":[]},{"name":"Table.FilterFn","comment":" Built-in filter functions, ported from `column-filtering/filterFns.ts`.\n\nA `FilterFn` is a comparison between a cell value and a filter value plus\nthree helpers that TanStack attaches to every filter fn:\n\n  - `resolveFilterValue` normalises the filter value once per filter before\n    any row is tested (the table does this, not [`filter`](#filter)).\n  - `resolveDataValue` normalises the cell value before comparison\n    ([`filter`](#filter) does this).\n  - `autoRemove` says when a filter value is blank enough that the filter\n    should be dropped from state.\n  - `meta`, when the filter fn has one, produces the value the filtered row\n    model records for the row under\n    [`Table.rowColumnFiltersMeta`](Table#rowColumnFiltersMeta). It is\n    TanStack's `addMeta` callback turned into a return value.\n\n\n# Type\n\n@docs FilterFn\n\n\n# Basic\n\n@docs equals, weakEquals\n\n\n# Strings\n\n@docs includesString, includesStringSensitive, equalsString, equalsStringSensitive, startsWith, endsWith\n\n\n# Blank\n\n@docs empty, notEmpty\n\n\n# Numbers\n\n@docs greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo\n\n\n# Ranges\n\n@docs between, betweenInclusive, inNumberRange, inDateRange\n\n\n# Arrays\n\n@docs arrHas, arrIncludes, arrIncludesAll, arrIncludesSome\n\n\n# Building your own\n\n@docs custom, withResolveFilterValue, withResolveDataValue, withAutoRemove, withMeta\n\n\n# Applying\n\n@docs filter, resolveFilterValue, resolveDataValue, autoRemove, meta\n\n\n# Dates\n\n@docs toDateTimestamp\n\n","unions":[{"name":"FilterFn","comment":" A filter comparison with its resolvers.\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"arrHas","comment":" Scalar cell equals at least one of the filter values.\n","type":"Table.FilterFn.FilterFn"},{"name":"arrIncludes","comment":" `List` or `String` cell includes at least one filter value.\n","type":"Table.FilterFn.FilterFn"},{"name":"arrIncludesAll","comment":" `List` cell includes every filter value.\n","type":"Table.FilterFn.FilterFn"},{"name":"arrIncludesSome","comment":" `List` cell includes at least one filter value.\n","type":"Table.FilterFn.FilterFn"},{"name":"autoRemove","comment":" Should this filter value cause the filter to be dropped?\n","type":"Table.FilterFn.FilterFn -> Table.Value.Value -> Basics.Bool"},{"name":"between","comment":" Exclusive range; the filter value is `List [ min, max ]`.\n","type":"Table.FilterFn.FilterFn"},{"name":"betweenInclusive","comment":" Inclusive range; the filter value is `List [ min, max ]`.\n","type":"Table.FilterFn.FilterFn"},{"name":"custom","comment":" Build a filter fn from a comparison. Resolvers default to `identity`\nand `autoRemove` defaults to removing `Null` and the empty string.\n","type":"(Table.Value.Value -> Table.Value.Value -> Basics.Bool) -> Table.FilterFn.FilterFn"},{"name":"empty","comment":" Keeps blank cells. The filter value is only an on/off flag.\n","type":"Table.FilterFn.FilterFn"},{"name":"endsWith","comment":" Case-insensitive suffix match.\n","type":"Table.FilterFn.FilterFn"},{"name":"equals","comment":" Strict equality.\n","type":"Table.FilterFn.FilterFn"},{"name":"equalsString","comment":" Case-insensitive string equality.\n","type":"Table.FilterFn.FilterFn"},{"name":"equalsStringSensitive","comment":" Case-sensitive string equality.\n","type":"Table.FilterFn.FilterFn"},{"name":"filter","comment":" Test a raw cell value against an already resolved filter value. The\ncell value is passed through `resolveDataValue` first; the filter value is\nnot (resolve it once with [`resolveFilterValue`](#resolveFilterValue)).\n","type":"Table.FilterFn.FilterFn -> Table.Value.Value -> Table.Value.Value -> Basics.Bool"},{"name":"greaterThan","comment":" Numeric when both sides parse as numbers, string comparison otherwise.\n","type":"Table.FilterFn.FilterFn"},{"name":"greaterThanOrEqualTo","comment":" See [`greaterThan`](#greaterThan).\n","type":"Table.FilterFn.FilterFn"},{"name":"inDateRange","comment":" Inclusive date range on `Date` cells (or timestamps, or `YYYY-MM-DD`\nstrings).\n","type":"Table.FilterFn.FilterFn"},{"name":"inNumberRange","comment":" Inclusive numeric range; only `Number` cells can match.\n","type":"Table.FilterFn.FilterFn"},{"name":"includesString","comment":" Case-insensitive substring match.\n","type":"Table.FilterFn.FilterFn"},{"name":"includesStringSensitive","comment":" Case-sensitive substring match.\n","type":"Table.FilterFn.FilterFn"},{"name":"lessThan","comment":" See [`greaterThan`](#greaterThan).\n","type":"Table.FilterFn.FilterFn"},{"name":"lessThanOrEqualTo","comment":" See [`greaterThan`](#greaterThan).\n","type":"Table.FilterFn.FilterFn"},{"name":"meta","comment":" The filter fn's meta producer, when [`withMeta`](#withMeta) gave it one.\n`Nothing` is the common case and lets the filtered row model skip the work\nentirely.\n","type":"Table.FilterFn.FilterFn -> Maybe.Maybe (Table.Value.Value -> Table.Value.Value -> Maybe.Maybe Table.Value.Value)"},{"name":"notEmpty","comment":" Keeps non-blank cells. The filter value is only an on/off flag.\n","type":"Table.FilterFn.FilterFn"},{"name":"resolveDataValue","comment":" Normalise a cell value.\n","type":"Table.FilterFn.FilterFn -> Table.Value.Value -> Table.Value.Value"},{"name":"resolveFilterValue","comment":" Normalise a filter value.\n","type":"Table.FilterFn.FilterFn -> Table.Value.Value -> Table.Value.Value"},{"name":"startsWith","comment":" Case-insensitive prefix match.\n","type":"Table.FilterFn.FilterFn"},{"name":"toDateTimestamp","comment":" `toDateTimestamp` from `filterFns.ts`: a `Date` gives its milliseconds,\na `Number` passes through, and everything else that is not a parseable date\nstring gives `NaN`, which never falls inside a range.\n\nElm has no `new Date(string)`, so the string form is limited to ISO 8601\n`YYYY-MM-DD`, optionally followed by `THH:MM`, `THH:MM:SS` and a `Z`.\n\n","type":"Table.Value.Value -> Basics.Float"},{"name":"weakEquals","comment":" Loose equality (`\"1\" == 1`).\n","type":"Table.FilterFn.FilterFn"},{"name":"withAutoRemove","comment":" Replace the auto-remove predicate.\n","type":"(Table.Value.Value -> Basics.Bool) -> Table.FilterFn.FilterFn -> Table.FilterFn.FilterFn"},{"name":"withMeta","comment":" Give a filter fn the meta the filtered row model records for every row it\ntests, TanStack's `addMeta` callback.\n\nThe function is handed the already resolved cell value and the already\nresolved filter value, the same two values [`filter`](#filter) compares, and\n`Nothing` records nothing for that row. This is how the fuzzy-filter example\nstores its match rank and then sorts by it.\n\n","type":"(Table.Value.Value -> Table.Value.Value -> Maybe.Maybe Table.Value.Value) -> Table.FilterFn.FilterFn -> Table.FilterFn.FilterFn"},{"name":"withResolveDataValue","comment":" Replace the cell-value normaliser.\n","type":"(Table.Value.Value -> Table.Value.Value) -> Table.FilterFn.FilterFn -> Table.FilterFn.FilterFn"},{"name":"withResolveFilterValue","comment":" Replace the filter-value normaliser.\n","type":"(Table.Value.Value -> Table.Value.Value) -> Table.FilterFn.FilterFn -> Table.FilterFn.FilterFn"}],"binops":[]},{"name":"Table.SortFn","comment":" Built-in sort functions, ported from `row-sorting/sortFns.ts`.\n\nA `SortFn` compares two cell values in ascending order. Descending order is\napplied by the sorted row model. Each sort fn carries an optional\n`resolveDataValue` normaliser that runs on both values before comparison,\nwhich is how the built-ins lowercase text or turn dates into timestamps.\n\n\n# Type\n\n@docs SortFn\n\n\n# Built-ins\n\n@docs alphanumeric, alphanumericCaseSensitive, text, textCaseSensitive, datetime, basic\n\n\n# Building your own\n\n@docs custom, withResolveDataValue\n\n\n# Applying\n\n@docs compare, resolveDataValue\n\n\n# Chunking\n\n@docs splitAlphaNumeric\n\n","unions":[{"name":"SortFn","comment":" An ascending comparison on cell values plus its value normaliser.\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"alphanumeric","comment":" Natural sort, case-insensitive: `item2` before `item10`.\n","type":"Table.SortFn.SortFn"},{"name":"alphanumericCaseSensitive","comment":" Natural sort, case-sensitive.\n","type":"Table.SortFn.SortFn"},{"name":"basic","comment":" Direct comparison with no normalisation.\n","type":"Table.SortFn.SortFn"},{"name":"compare","comment":" Compare two raw cell values: both are passed through the normaliser, then\nthe comparison runs.\n","type":"Table.SortFn.SortFn -> Table.Value.Value -> Table.Value.Value -> Basics.Order"},{"name":"custom","comment":" Build a sort fn from a comparison. Use [`withResolveDataValue`](#withResolveDataValue)\nto add a normaliser.\n","type":"(Table.Value.Value -> Table.Value.Value -> Basics.Order) -> Table.SortFn.SortFn"},{"name":"datetime","comment":" Chronological sort on `Date` values (and numeric timestamps).\n\n`Date` values become millisecond timestamps first; anything else is compared\nwith JavaScript's relational rules, so two strings compare as strings and\neverything else compares numerically.\n\n","type":"Table.SortFn.SortFn"},{"name":"resolveDataValue","comment":" Run only the normaliser.\n","type":"Table.SortFn.SortFn -> Table.Value.Value -> Table.Value.Value"},{"name":"splitAlphaNumeric","comment":" The Elm counterpart of splitting a string with TanStack's\n`reSplitAlphaNumeric` regex (`/([0-9]+)/gm`): runs of digits become their own\nsegments, and the empty segments JavaScript leaves at the boundaries are kept.\n\n    splitAlphaNumeric \"apple\" == [ \"apple\" ]\n\n    splitAlphaNumeric \"item10\" == [ \"item\", \"10\", \"\" ]\n\n    splitAlphaNumeric \"10abc\" == [ \"\", \"10\", \"abc\" ]\n\n    splitAlphaNumeric \"\" == [ \"\" ]\n\n","type":"String.String -> List.List String.String"},{"name":"text","comment":" Plain lexicographic sort, case-insensitive.\n","type":"Table.SortFn.SortFn"},{"name":"textCaseSensitive","comment":" Plain lexicographic sort, case-sensitive.\n","type":"Table.SortFn.SortFn"},{"name":"withResolveDataValue","comment":" Replace the normaliser that runs on both values before comparison.\n","type":"(Table.Value.Value -> Table.Value.Value) -> Table.SortFn.SortFn -> Table.SortFn.SortFn"}],"binops":[]},{"name":"Table.Value","comment":" The one union type for cell values.\n\nColumn accessors return a `Value`. Built-in sort, filter, and aggregation\nfunctions operate on `Value`. Custom sort and filter functions receive the\noriginal `row` instead, so users are never forced through `Value` for their\nown logic.\n\n`Null` stands in for both JavaScript `null` and `undefined`. `List` is the\nElm counterpart of a JavaScript array cell value and exists so the array\nfilter functions (`arrIncludes`, `arrIncludesAll`, `arrIncludesSome`) and\nthe `extent` / `unique` aggregations can be expressed faithfully.\n\n\n# Type\n\n@docs Value\n\n\n# Helpers\n\n@docs toString, toNumber, isNull\n\n","unions":[{"name":"Value","comment":" A cell value.\n","args":[],"cases":[["String",["String.String"]],["Number",["Basics.Float"]],["Bool",["Basics.Bool"]],["Date",["Time.Posix"]],["List",["List.List Table.Value.Value"]],["Null",[]]]}],"aliases":[],"values":[{"name":"isNull","comment":" `True` only for `Null`.\n","type":"Table.Value.Value -> Basics.Bool"},{"name":"toNumber","comment":" Coerce a value to a number the way JavaScript's `Number(x)` does.\n\n    toNumber (Number 29) == 29\n\n    toNumber (String \"29\") == 29\n\n    toNumber (String \"\") == 0\n\n    toNumber (Bool True) == 1\n\n    toNumber Null == 0\n\nA value that does not coerce, such as `String \"abc\"`, gives `NaN`, which\ncompares `False` against everything just as it does in JavaScript. A `Date`\ncoerces to its millisecond timestamp and a one-element `List` coerces to its\nelement, both matching `Number(x)`.\n\n","type":"Table.Value.Value -> Basics.Float"},{"name":"toString","comment":" Coerce a value to a string the way JavaScript's `String(x)` does, except\nthat `Null` becomes the empty string (TanStack writes `String(x ?? '')` at\nevery call site that matters).\n\n    toString (Number 1) == \"1\"\n\n    toString (Number 1.5) == \"1.5\"\n\n    toString (Bool True) == \"true\"\n\n    toString Null == \"\"\n\n","type":"Table.Value.Value -> String.String"}],"binops":[]}]