@scattered-light/loomiere-base-ui 0.6.0 → 0.7.0

package/dist/custom/collection/index.d.ts

@@ -0,0 +1,534 @@
+import * as React from 'react';
+import { ReactNode, MutableRefObject } from 'react';
+import { ColumnDef, Table, Row, FilterFn } from '@tanstack/react-table';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _tanstack_table_core from '@tanstack/table-core';
+
+type CollectionKind = 'text' | 'number' | 'money' | 'percent' | 'date' | 'boolean';
+type CollectionAlign = 'start' | 'end' | 'center';
+type ListSlot = 'primary' | 'secondary' | 'meta' | 'amount' | 'status' | 'hidden';
+type FilterKind = 'tabs' | 'select' | 'multi-select' | 'boolean';
+interface FilterOption {
+    value: string;
+    label: string;
+    /** A tab with an empty value, or this flag, means no filter. Its count is the whole facet. */
+    all?: boolean;
+}
+interface CollectionFilter {
+    kind: FilterKind;
+    label?: string;
+    options?: FilterOption[];
+}
+interface CellContext {
+    view: 'table' | 'list';
+    selected: boolean;
+    active: boolean;
+}
+interface CollectionColumn<T> {
+    id: string;
+    header: string | {
+        label: string;
+        content: ReactNode;
+    };
+    value: (row: T) => unknown;
+    cell?: (row: T, ctx: CellContext) => ReactNode;
+    kind?: CollectionKind;
+    currency?: string | ((row: T) => string);
+    fractionDigits?: number;
+    negative?: 'minus' | 'parens';
+    /** True searches the formatted value. A function also searches text that is not shown. */
+    searchable?: boolean | ((row: T) => string | string[]);
+    sortable?: boolean;
+    filter?: CollectionFilter;
+    total?: 'sum' | 'count' | ((rows: T[]) => ReactNode);
+    /** The row's name. One column should set this. Its cell is the row header and the primary action. */
+    rowHeader?: boolean;
+    hidden?: boolean;
+    /** 'auto', 'min' (as wide as the content), or a size token path such as space.16. No pixel values. */
+    width?: 'auto' | 'min' | string;
+    align?: CollectionAlign;
+    list?: ListSlot;
+    dateFormat?: Intl.DateTimeFormatOptions;
+    /** When every row shares one currency, the header can say "Amount (USD)" and the cells drop the symbol. */
+    showCurrencyInHeader?: boolean;
+    /** Rare needs that the column shape does not cover. Merged into the TanStack column. */
+    tanstack?: Partial<ColumnDef<any, any>>;
+}
+declare function headerLabel<T>(column: CollectionColumn<T>): string;
+declare function defineColumns<T>(columns: CollectionColumn<T>[]): CollectionColumn<T>[];
+
+declare const collectionFeatures: {
+    rowSortingFeature: _tanstack_table_core.TableFeature;
+    columnFilteringFeature: _tanstack_table_core.TableFeature;
+    globalFilteringFeature: _tanstack_table_core.TableFeature;
+    columnFacetingFeature: _tanstack_table_core.TableFeature;
+    rowPaginationFeature: _tanstack_table_core.TableFeature;
+    rowSelectionFeature: _tanstack_table_core.TableFeature;
+    columnGroupingFeature: _tanstack_table_core.TableFeature;
+    rowExpandingFeature: _tanstack_table_core.TableFeature;
+    columnOrderingFeature: _tanstack_table_core.TableFeature;
+    columnVisibilityFeature: _tanstack_table_core.TableFeature;
+    sortedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+    filteredRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+    groupedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+    expandedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+    paginatedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+    facetedRowModel: (table: Table<any, any>, columnId: string) => () => _tanstack_table_core.RowModel<any, any>;
+    facetedUniqueValues: (table: Table<_tanstack_table_core.TableFeatures, any>, columnId: string) => () => Map<any, number>;
+};
+type CollectionTable = Table<typeof collectionFeatures, any>;
+type CollectionRow = Row<typeof collectionFeatures, any>;
+interface CollectionModelInput<T> {
+    rows: readonly T[];
+    columns: CollectionColumn<T>[];
+    getRowId: (row: T) => string;
+    getSubRows?: (row: T) => readonly T[] | undefined;
+    locale: string;
+    state?: Record<string, unknown>;
+    initialState?: Record<string, unknown>;
+    onStateChange?: Record<string, (updater: unknown) => void>;
+    canSelect?: (row: T) => boolean;
+}
+declare function collectionTableOptions<T>(input: CollectionModelInput<T>): {
+    features: {
+        rowSortingFeature: _tanstack_table_core.TableFeature;
+        columnFilteringFeature: _tanstack_table_core.TableFeature;
+        globalFilteringFeature: _tanstack_table_core.TableFeature;
+        columnFacetingFeature: _tanstack_table_core.TableFeature;
+        rowPaginationFeature: _tanstack_table_core.TableFeature;
+        rowSelectionFeature: _tanstack_table_core.TableFeature;
+        columnGroupingFeature: _tanstack_table_core.TableFeature;
+        rowExpandingFeature: _tanstack_table_core.TableFeature;
+        columnOrderingFeature: _tanstack_table_core.TableFeature;
+        columnVisibilityFeature: _tanstack_table_core.TableFeature;
+        sortedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        filteredRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        groupedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        expandedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        paginatedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedRowModel: (table: Table<any, any>, columnId: string) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedUniqueValues: (table: Table<_tanstack_table_core.TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    };
+    data: T[];
+    columns: ColumnDef<{
+        rowSortingFeature: _tanstack_table_core.TableFeature;
+        columnFilteringFeature: _tanstack_table_core.TableFeature;
+        globalFilteringFeature: _tanstack_table_core.TableFeature;
+        columnFacetingFeature: _tanstack_table_core.TableFeature;
+        rowPaginationFeature: _tanstack_table_core.TableFeature;
+        rowSelectionFeature: _tanstack_table_core.TableFeature;
+        columnGroupingFeature: _tanstack_table_core.TableFeature;
+        rowExpandingFeature: _tanstack_table_core.TableFeature;
+        columnOrderingFeature: _tanstack_table_core.TableFeature;
+        columnVisibilityFeature: _tanstack_table_core.TableFeature;
+        sortedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        filteredRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        groupedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        expandedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        paginatedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedRowModel: (table: Table<any, any>, columnId: string) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedUniqueValues: (table: Table<_tanstack_table_core.TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    }, any>[];
+    getRowId: (row: T) => string;
+    getSubRows: ((row: T) => T[] | undefined) | undefined;
+    filterFromLeafRows: boolean;
+    getColumnCanGlobalFilter: (column: {
+        columnDef: {
+            meta?: CollectionColumn<T>;
+        };
+    }) => boolean;
+    enableRowSelection: boolean | ((row: {
+        original: T;
+    }) => boolean);
+    enableMultiRowSelection: boolean;
+    enableSubRowSelection: boolean;
+    globalFilterFn: FilterFn<{
+        rowSortingFeature: _tanstack_table_core.TableFeature;
+        columnFilteringFeature: _tanstack_table_core.TableFeature;
+        globalFilteringFeature: _tanstack_table_core.TableFeature;
+        columnFacetingFeature: _tanstack_table_core.TableFeature;
+        rowPaginationFeature: _tanstack_table_core.TableFeature;
+        rowSelectionFeature: _tanstack_table_core.TableFeature;
+        columnGroupingFeature: _tanstack_table_core.TableFeature;
+        rowExpandingFeature: _tanstack_table_core.TableFeature;
+        columnOrderingFeature: _tanstack_table_core.TableFeature;
+        columnVisibilityFeature: _tanstack_table_core.TableFeature;
+        sortedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        filteredRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        groupedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        expandedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        paginatedRowModel: (table: Table<any, any>) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedRowModel: (table: Table<any, any>, columnId: string) => () => _tanstack_table_core.RowModel<any, any>;
+        facetedUniqueValues: (table: Table<_tanstack_table_core.TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    }, any>;
+    meta: {
+        locale: string;
+        columns: CollectionColumn<T>[];
+    };
+    state: Record<string, unknown> | undefined;
+    initialState: Record<string, unknown> | undefined;
+    onGlobalFilterChange: ((updater: unknown) => void) | undefined;
+    onSortingChange: ((updater: unknown) => void) | undefined;
+    onColumnFiltersChange: ((updater: unknown) => void) | undefined;
+    onPaginationChange: ((updater: unknown) => void) | undefined;
+    onRowSelectionChange: ((updater: unknown) => void) | undefined;
+    onGroupingChange: ((updater: unknown) => void) | undefined;
+    onExpandedChange: ((updater: unknown) => void) | undefined;
+    onColumnOrderChange: ((updater: unknown) => void) | undefined;
+    onColumnVisibilityChange: ((updater: unknown) => void) | undefined;
+    autoResetPageIndex: boolean;
+    autoResetExpanded: boolean;
+};
+
+/**
+ * Search, sort, money and paging rules for a collection. No React: the hook and the
+ * tests both call these, and TanStack applies the comparators. It is not a second
+ * filter engine. Faceting, selection and the row models stay in TanStack.
+ */
+type SortKind = 'text' | 'number' | 'money' | 'percent' | 'date' | 'boolean';
+type NegativeStyle = 'minus' | 'parens';
+type BalanceTone = 'balanced' | 'under' | 'over';
+/**
+ * Exact decimal to integer minor units. Strings never pass through a float.
+ * A number is turned into its decimal text first. Multiplying by 10 ** digits rounds
+ * 1.005 down to 1.00, because the float is 1.004999….
+ */
+declare function toMinor(value: number | string | null | undefined, digits: number): bigint | null;
+declare function compareDecimal(a: number | string, b: number | string): number;
+interface SortItem<T> {
+    value: unknown;
+    index: number;
+    row: T;
+}
+/**
+ * Empty values sort last in either direction. Ties keep the incoming order.
+ * `desc` flips only the real values, never the empty ones.
+ */
+declare function sortRows<T>(items: SortItem<T>[], kind: SortKind, desc: boolean, locale: string): T[];
+declare function formatMoney(value: number | string | null | undefined, options: {
+    locale: string;
+    currency: string;
+    fractionDigits?: number;
+    negative?: NegativeStyle;
+}): string;
+declare function formatDate(value: unknown, locale: string, dateFormat?: Intl.DateTimeFormatOptions): string;
+/** Every word must match, in any order. An empty query matches everything. */
+declare function searchMatches(query: string, haystack: string): boolean;
+interface MoneySum {
+    currency: string | null;
+    minor: bigint | null;
+    mixed: boolean;
+}
+declare function sumMoney(values: Array<{
+    amount: number | string | null | undefined;
+    currency: string;
+}>, fractionDigits?: number): MoneySum;
+declare function balanceOf(amounts: Array<number | string | null | undefined>, control: number | string | null | undefined, currency: string): {
+    tone: BalanceTone;
+    allocated: bigint;
+    control: bigint;
+    delta: bigint;
+    digits: number;
+};
+interface PageBounds {
+    pageIndex: number;
+    pageCount: number;
+    start: number;
+    end: number;
+}
+/** `pageIndex` is zero-based. A page past the end clamps to the last page. An empty list is one blank page. */
+declare function pageBounds(pageIndex: number, pageSize: number, total: number): PageBounds;
+interface FlatEntry<T> {
+    kind: 'group' | 'leaf';
+    row: T;
+    groupId?: string;
+}
+/**
+ * Page by leaf rows. A group that starts before this page repeats, marked continued.
+ */
+declare function pageFlat<T>(entries: FlatEntry<T>[], pageIndex: number, pageSize: number): {
+    entries: Array<FlatEntry<T> & {
+        continued?: boolean;
+    }>;
+    leafCount: number;
+    bounds: PageBounds;
+};
+/** Ids that match, plus every ancestor, so a match is never shown without its parent. */
+declare function treeVisibleIds<T>(rows: readonly T[], getId: (row: T) => string, getChildren: (row: T) => readonly T[] | undefined, matches: (row: T) => boolean): Set<string>;
+/** Counts of one column among rows that already satisfy the other filters. */
+declare function countFacets<T>(rows: readonly T[], valueOf: (row: T) => unknown): Map<string, number>;
+/** Drop ids whose row is gone, or that no longer pass canSelect. Children count too. */
+declare function selectableIds<T>(ids: readonly string[], rows: readonly T[], getRowId: (row: T) => string, canSelect?: (row: T) => boolean, getSubRows?: (row: T) => readonly T[] | undefined): string[];
+declare function hiddenSelectedCount(selectedIds: readonly string[], filteredIds: ReadonlySet<string>): number;
+/** Ascending, then descending, then the system's default. Clicking the default itself starts at ascending. */
+declare function nextSort(current: {
+    id: string;
+    desc: boolean;
+} | null, columnId: string, initial: {
+    id: string;
+    desc: boolean;
+} | null): {
+    id: string;
+    desc: boolean;
+} | null;
+
+interface CollectionSort {
+    id: string;
+    desc: boolean;
+}
+interface CollectionMessages {
+    selectAll: (count: number) => string;
+    actionsFor: (name: string) => string;
+    total: string;
+    selected: (count: number) => string;
+    hiddenByFilters: (count: number) => string;
+    noResults: string;
+    noResultsDescription: string;
+    clearFilters: string;
+    nothingHere: string;
+    previous: string;
+    next: string;
+    rowsPerPage: string;
+    selectionCleared: string;
+    loading: string;
+}
+interface UseCollectionOptions<T> {
+    rows: readonly T[];
+    columns: CollectionColumn<T>[];
+    getRowId: (row: T) => string;
+    initialSort?: CollectionSort;
+    initialFilters?: Record<string, unknown>;
+    /** Omit it and the table has no selection column. */
+    canSelect?: (row: T) => boolean;
+    /** Omit it and every filtered row is on one page. */
+    pageSize?: number;
+    groupBy?: string;
+    getSubRows?: (row: T) => readonly T[] | undefined;
+    /** Groups and tree parents start open. Pass false to start them closed. */
+    defaultExpanded?: boolean;
+    /** Page sizes the control offers. A stored size outside this list is dropped. */
+    pageSizeOptions?: number[];
+    /** Remember search, sort, filters, page size and grouping for this screen. Not the selection or the page. */
+    stateKey?: string;
+    messages?: Partial<CollectionMessages>;
+    storage?: Pick<Storage, 'getItem' | 'setItem'>;
+    locale?: string;
+    /** Dryden clears the selection when a refresh replaces the rows. Default keeps it. */
+    clearSelectionOnRowsChange?: boolean;
+    search?: string;
+    onSearchChange?: (value: string) => void;
+    sort?: CollectionSort | null;
+    onSortChange?: (sort: CollectionSort | null) => void;
+    filters?: Record<string, unknown>;
+    onFiltersChange?: (filters: Record<string, unknown>) => void;
+    selection?: string[];
+    onSelectionChange?: (ids: string[]) => void;
+    /** 1-based. */
+    page?: number;
+    onPageChange?: (page: number) => void;
+    grouping?: string | null;
+    onGroupingChange?: (grouping: string | null) => void;
+    columnOrder?: string[];
+    onColumnOrderChange?: (order: string[]) => void;
+    columnVisibility?: Record<string, boolean>;
+    onColumnVisibilityChange?: (visibility: Record<string, boolean>) => void;
+}
+interface CollectionApi<T> {
+    table: CollectionTable;
+    columns: CollectionColumn<T>[];
+    getRowId: (row: T) => string;
+    locale: string;
+    search: string;
+    setSearch: (value: string) => void;
+    sort: CollectionSort | null;
+    setSort: (sort: CollectionSort | null) => void;
+    cycleSort: (columnId: string) => void;
+    filters: Record<string, unknown>;
+    setFilter: (columnId: string, value: unknown) => void;
+    clearFilters: () => void;
+    facetCounts: (columnId: string) => Map<string, number>;
+    selection: string[];
+    selectedRows: T[];
+    selectAllFiltered: () => void;
+    clearSelection: () => void;
+    /** Drops the selection of rows the current filters still show. Hidden rows stay selected. */
+    clearFilteredSelection: () => void;
+    selectionSet: ReadonlySet<string>;
+    messages: CollectionMessages;
+    hiddenSelectedCount: number;
+    filteredRows: T[];
+    filteredCount: number;
+    totalCount: number;
+    totals: Record<string, string>;
+    page: number;
+    pageCount: number;
+    setPage: (page: number) => void;
+    pageSize?: number;
+    setPageSize: (size: number) => void;
+    isFiltered: boolean;
+    reset: () => void;
+    grouping: string | null;
+    setGrouping: (columnId: string | null) => void;
+    columnOrder: string[];
+    setColumnOrder: (order: string[]) => void;
+    columnVisibility: Record<string, boolean>;
+    setColumnVisibility: (visibility: Record<string, boolean>) => void;
+    canSelect?: (row: T) => boolean;
+    /** The rows of this page, with group headers repeated when a group continues. */
+    pageEntries: Array<FlatEntry<CollectionRow> & {
+        continued?: boolean;
+    }>;
+    rowHeaderId?: string;
+    registerRowFocus: (focus: (() => void) | null) => void;
+    focusFirstRow: () => void;
+    /** Set when the page changes. The view focuses the first row after that page has rendered. */
+    focusAfterPage: MutableRefObject<boolean>;
+}
+declare function useCollection<T>(options: UseCollectionOptions<T>): CollectionApi<T>;
+
+interface CollectionViewProps<T> {
+    collection: CollectionApi<T>;
+    label: string;
+    onRowActivate?: (row: T) => void;
+    getRowHref?: (row: T) => string;
+    activeRowId?: string;
+    rowActions?: (row: T) => RowAction[];
+    /** Shown when the data itself is empty. A search with no matches uses the built-in no-results state. */
+    empty?: React.ReactNode;
+    loading?: boolean;
+    /**
+     * One tab stop for the rows. Defaults to on when a row can be activated.
+     * `data-no-activate` on a control inside a row keeps a click there from opening the row.
+     */
+    rowNavigation?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+}
+interface RowAction {
+    label: string;
+    onSelect: () => void;
+    disabled?: boolean;
+    tone?: 'danger';
+}
+
+interface DataListProps<T> extends CollectionViewProps<T> {
+    /** 'rows' share one container, like the table body. 'cards' separates them when a queue should read as items. */
+    variant?: 'rows' | 'cards';
+    totals?: 'summary' | 'none';
+    renderItemExtra?: (row: T) => React.ReactNode;
+}
+/**
+ * The same rows as DataTable, read as a list. Sorting lives in the toolbar because a list has no headers.
+ */
+declare function DataList<T>({ collection, label, onRowActivate, getRowHref, activeRowId, rowActions, empty, loading, rowNavigation, size, className, variant, totals, renderItemExtra, }: DataListProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DataTableProps<T> extends CollectionViewProps<T> {
+    /** Accessible name when there is no caption. */
+    label: string;
+    caption?: React.ReactNode;
+    stickyHeader?: boolean;
+    stickyRowHeader?: boolean;
+    /** 'scroll' keeps the table. 'list' swaps in DataList when the table is narrower than collection.narrow-width. */
+    narrow?: 'scroll' | 'list';
+    size?: 'sm' | 'md';
+}
+/**
+ * A data table, the APG pattern: one tab stop for the rows, headers announce sort, and it is
+ * not a grid. A grid would say this is a spreadsheet, and it is not. AG Grid is that tool.
+ */
+declare function DataTable<T>({ collection, label, caption, onRowActivate, getRowHref, activeRowId, rowActions, empty, loading, stickyHeader, stickyRowHeader, narrow, size, rowNavigation, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface CollectionPaginationProps {
+    /** 1-based. */
+    page: number;
+    pageCount: number;
+    pageSize?: number;
+    total: number;
+    filtered?: boolean;
+    onPageChange: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+    pageSizeOptions?: number[];
+    /** Used in the nav label: "Pagination for Transactions". */
+    label: string;
+    previousLabel?: string;
+    nextLabel?: string;
+    rowsPerPageLabel?: string;
+    className?: string;
+}
+/**
+ * Generic on purpose: page, pageCount, pageSize, total and onPageChange are enough
+ * to use it without a collection. A collection passes those through.
+ */
+declare function CollectionPagination({ page, pageCount, pageSize, total, filtered, onPageChange, onPageSizeChange, pageSizeOptions, label, previousLabel, nextLabel, rowsPerPageLabel, className, }: CollectionPaginationProps): react_jsx_runtime.JSX.Element;
+
+interface CollectionToolbarProps<T> {
+    collection: CollectionApi<T>;
+    /** Required when any column is searchable. */
+    searchLabel?: string;
+    searchLabelVisible?: boolean;
+    /** The table sorts from its headers. The list, and a table that asks, sorts from here. */
+    showSort?: boolean;
+    /** Adds a Group by select. The hook already holds the grouping. */
+    groupOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+    actions?: React.ReactNode;
+    bulkActions?: React.ReactNode;
+    className?: string;
+}
+/**
+ * Tabs and search stay put while rows are selected. The trailing controls swap for the
+ * selection bar, so the bar takes their place and the row does not grow.
+ */
+declare function CollectionToolbarImpl<T>({ collection, searchLabel, searchLabelVisible, showSort, groupOptions, actions, bulkActions, className }: CollectionToolbarProps<T>): react_jsx_runtime.JSX.Element;
+declare function ToolbarTabs<T>({ collection, column }: {
+    collection: CollectionApi<T>;
+    column: CollectionColumn<T>;
+}): react_jsx_runtime.JSX.Element;
+declare function SearchField({ label, visible, value, onChange }: {
+    label: string;
+    visible?: boolean;
+    value: string;
+    onChange: (value: string) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function FilterControl<T>({ collection, column }: {
+    collection: CollectionApi<T>;
+    column: CollectionColumn<T>;
+}): react_jsx_runtime.JSX.Element;
+declare function SortControl<T>({ collection }: {
+    collection: CollectionApi<T>;
+}): react_jsx_runtime.JSX.Element;
+declare function ToolbarClear<T>({ collection }: {
+    collection: CollectionApi<T>;
+}): react_jsx_runtime.JSX.Element | null;
+declare function ToolbarActions({ children }: {
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function ToolbarSelection<T>({ collection, children }: {
+    collection: CollectionApi<T>;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function ToolbarRoot({ className, children }: {
+    className?: string;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare const CollectionToolbar: typeof CollectionToolbarImpl & {
+    Root: typeof ToolbarRoot;
+    Tabs: typeof ToolbarTabs;
+    Search: typeof SearchField;
+    Filter: typeof FilterControl;
+    Sort: typeof SortControl;
+    Clear: typeof ToolbarClear;
+    Actions: typeof ToolbarActions;
+    SelectionBar: typeof ToolbarSelection;
+};
+
+/**
+ * Totals add leaf rows. A tree parent's amount is the children already, so counting both would double it.
+ * Zero money rows use the column's currency. "Mixed currencies" is only when more than one currency is present.
+ * A number or percent sum is not money.
+ */
+declare function totalText<T>(column: CollectionColumn<T>, rows: readonly T[], locale: string): string;
+
+export { type CellContext, type CollectionAlign, type CollectionApi, type CollectionColumn, type CollectionFilter, type CollectionKind, CollectionPagination, type CollectionPaginationProps, type CollectionSort, CollectionToolbar, type CollectionToolbarProps, DataList, type DataListProps, DataTable, type DataTableProps, type FilterKind, type FilterOption, type ListSlot, type UseCollectionOptions, balanceOf, collectionTableOptions, compareDecimal, countFacets, defineColumns, formatDate, formatMoney, headerLabel, hiddenSelectedCount, nextSort, pageBounds, pageFlat, searchMatches, selectableIds, sortRows, sumMoney, toMinor, totalText, treeVisibleIds, useCollection };