@x12i/data 1.0.0 → 1.1.0

package/dist/messages-BF20Mq97.d.ts

@@ -0,0 +1,508 @@
+/**
+ * Contracts for the kit's DataGrid (spec section 7). The grid's data pipeline
+ * is this package's own headless engine and its windowing is TanStack Virtual;
+ * these types are the stable surface that apps, reports and charts depend on.
+ *
+ * Everything here is additive over the first release: a `ColumnDef` written
+ * for 1.0.0 still type-checks and means the same thing.
+ */
+type SortDirection = "asc" | "desc";
+interface SortModelItem {
+    /** The column `id` the sort applies to. Server requests carry `column.field ?? column.id`. */
+    field: string;
+    direction: SortDirection;
+}
+type FilterOperator = "contains" | "not-contains" | "starts-with" | "equals" | "not-equals" | "gt" | "gte" | "lt" | "lte" | "between" | "in" | "before" | "after" | "is-empty" | "is-not-empty";
+interface FilterModelItem {
+    /** The column `id` the filter applies to. */
+    field: string;
+    operator: FilterOperator;
+    /** Absent for `is-empty` and `is-not-empty`. An array for `in` and `between`. */
+    value?: unknown;
+}
+interface GroupModelItem {
+    /** The column `id` to group by. */
+    field: string;
+}
+/** What the grid asks a server for. Row indexes are zero-based and `endRow` is exclusive. */
+interface GetRowsRequest {
+    startRow: number;
+    endRow: number;
+    sort: SortModelItem[];
+    filter: FilterModelItem[];
+    group: GroupModelItem[];
+    /** The quick-search text, when the grid has any. */
+    quickFilter?: string;
+    /**
+     * Cursor from the previous block's `nextCursor`, for APIs that page by cursor
+     * instead of offset. `null` for the first block.
+     */
+    cursor?: string | null;
+}
+interface GetRowsResult<Row> {
+    rows: Row[];
+    /** Total rows matching the filter, so the grid can size its scrollbar. */
+    total: number;
+    /** Cursor for the block after this one. Present only for cursor-paged APIs. */
+    nextCursor?: string | null;
+}
+interface GetRowsOptions {
+    /** Aborted when the grid no longer needs the answer, for example after a new sort. */
+    signal?: AbortSignal;
+}
+/** The server data source: `getRows({ startRow, endRow, sort, filter, group })` returns `{ rows, total }`. */
+interface ServerDataSource<Row> {
+    getRows(request: GetRowsRequest, options?: GetRowsOptions): Promise<GetRowsResult<Row>>;
+}
+/** Cell renderers the grid ships (spec section 7). */
+type CellType = "text" | "number" | "currency" | "percent" | "date" | "datetime" | "boolean" | "status" | "avatar" | "progress" | "sparkline" | "link" | "tags" | "actions" | "custom";
+/** Logical sides, so a pinned column follows the reading direction in RTL. */
+type ColumnPin = "start" | "end";
+/** Cell text alignment on the inline axis. Numeric types default to `end`. */
+type ColumnAlign = "start" | "center" | "end";
+/** Tones of the kit `Badge`, shared by status cells and charts. */
+type StatusTone = "neutral" | "accent" | "success" | "warning" | "danger" | "info";
+/** One choice of an enum column: status badge, select editor and set filter. */
+interface ColumnOption {
+    value: string;
+    /** Display text. Pass a translated string. */
+    label: string;
+    /** Badge tone for `status` cells. */
+    tone?: StatusTone;
+}
+type AggregateName = "sum" | "avg" | "min" | "max" | "count";
+/** A custom aggregate: receives the column's values and the rows they came from. */
+type AggregateFn<Row> = (values: unknown[], rows: Row[]) => unknown;
+/** The filter UI and operators a column offers. Derived from `cellType` when absent. */
+type ColumnFilterType = "text" | "number" | "date" | "enum" | "boolean";
+type ColumnEditor = "text" | "number" | "select" | "boolean" | "date";
+interface ColumnDef<Row> {
+    /** Stable identifier, also used in saved views. */
+    id: string;
+    /** Header text. Pass a translated string. */
+    header: string;
+    /** Property of the row to read. */
+    field?: Extract<keyof Row, string>;
+    cellType?: CellType;
+    /**
+     * An `Intl`-based format name, by cell type. Number: `integer`, `compact`,
+     * `decimal:2`, `unit:kilobyte`. Currency: an ISO code such as `EUR`. Percent:
+     * `whole` when the value is 0 to 100 instead of a fraction. Date and datetime:
+     * `short`, `medium`, `long`, `full`, `iso`.
+     */
+    format?: string;
+    width?: number;
+    minWidth?: number;
+    pinned?: ColumnPin;
+    sortable?: boolean;
+    filterable?: boolean;
+    resizable?: boolean;
+    editable?: boolean;
+    maxWidth?: number;
+    align?: ColumnAlign;
+    /** Reads the value when `field` is not enough, for example a nested property. */
+    accessor?: (row: Row) => unknown;
+    /**
+     * Text for a value. Used by CSV export, copy, quick search and screen readers,
+     * and by the default cell renderer. Overrides `format`.
+     */
+    formatter?: (value: unknown, row: Row) => string;
+    /** Replaces the default comparison. Return a negative, zero or positive number. */
+    comparator?: (a: unknown, b: unknown, rowA: Row, rowB: Row) => number;
+    /** Shown in group rows and in the totals footer. */
+    aggregate?: AggregateName | AggregateFn<Row>;
+    filterType?: ColumnFilterType;
+    /** Choices for `status` cells, enum filters and select editors. */
+    options?: ColumnOption[];
+    /** ISO 4217 code for `currency` cells. Defaults to `USD`. */
+    currency?: string;
+    numberFormat?: Intl.NumberFormatOptions;
+    dateFormat?: Intl.DateTimeFormatOptions;
+    /** Maximum for `progress` cells. Defaults to 100. */
+    progressMax?: number;
+    editor?: ColumnEditor;
+    /** Per-row editability on top of `editable`. */
+    canEdit?: (row: Row) => boolean;
+    /** Return an error message to reject an edit, or nothing to accept it. */
+    validate?: (value: unknown, row: Row) => string | null | undefined;
+    /** Turns the editor's text into a value. Defaults by editor type. */
+    parseValue?: (input: string, row: Row) => unknown;
+    /** Hidden until the user shows the column. */
+    hidden?: boolean;
+    /** `false` keeps the column out of the visibility menu. Default `true`. */
+    hideable?: boolean;
+    /** `false` keeps the column out of the grouping menu. Default `true`. */
+    groupable?: boolean;
+    /** `false` leaves the column out of quick search. */
+    searchable?: boolean;
+    /** Adjacent columns with the same `group` share a header above them. */
+    group?: string;
+    /** Free-form data for custom renderers. The grid never reads it. */
+    meta?: Record<string, unknown>;
+}
+/** Identity helper that infers `Row` for column authoring. */
+declare function defineColumns<Row>(columns: ColumnDef<Row>[]): ColumnDef<Row>[];
+interface ColumnState {
+    id: string;
+    width?: number;
+    hidden?: boolean;
+    pinned?: ColumnPin;
+}
+declare const SAVED_VIEW_VERSION = 1;
+/** Column state, filters and sort, serialized to JSON. */
+interface SavedView {
+    version: typeof SAVED_VIEW_VERSION;
+    name?: string;
+    columns: ColumnState[];
+    sort: SortModelItem[];
+    filter: FilterModelItem[];
+    group?: GroupModelItem[];
+}
+/** Every filter operator, as a runtime list for validation and pickers. */
+declare const FILTER_OPERATORS: readonly ["contains", "not-contains", "starts-with", "equals", "not-equals", "gt", "gte", "lt", "lte", "between", "in", "before", "after", "is-empty", "is-not-empty"];
+
+interface FormatLabels {
+    yes: string;
+    no: string;
+}
+/** English labels for boolean values. The grid replaces them with its `messages`. */
+declare const defaultFormatLabels: FormatLabels;
+interface FormatContext {
+    /** BCP 47 locale for `Intl`. Defaults to the runtime locale. */
+    locale?: string;
+    /** IANA time zone for dates and times. Date-only values always format in UTC. */
+    timeZone?: string;
+    labels?: FormatLabels;
+}
+type CellFormatter<Row> = (value: unknown, row: Row) => string;
+/** `Intl.NumberFormat` options for a numeric column, from `cellType`, `format` and the overrides. */
+declare function resolveNumberFormatOptions<Row>(column: ColumnDef<Row>): Intl.NumberFormatOptions;
+/** `Intl.DateTimeFormat` options for a date or datetime column. */
+declare function resolveDateFormatOptions<Row>(column: ColumnDef<Row>): Intl.DateTimeFormatOptions;
+/**
+ * Builds a formatter for a column once, so formatting 100,000 cells reuses one
+ * `Intl` object. A column's own `formatter` always wins. Empty values give "".
+ *
+ * Without a `cellType`, the value decides: numbers use number format, dates use
+ * date format, booleans use yes/no, arrays join.
+ */
+declare function createCellFormatter<Row>(column: ColumnDef<Row>, ctx?: FormatContext): CellFormatter<Row>;
+/** One-off formatting. Prefer `createCellFormatter` when formatting many cells. */
+declare function formatCellValue<Row>(column: ColumnDef<Row>, value: unknown, row: Row, ctx?: FormatContext): string;
+
+/**
+ * Row selection as a plain immutable value.
+ *
+ * `include` lists the selected ids. `exclude` means "every row except these
+ * ids": it is how "select all rows" works when the grid cannot list ids, for
+ * example when a server holds the rows. Both are safe to keep in React state.
+ */
+interface SelectionState {
+    readonly mode: "include" | "exclude";
+    readonly ids: ReadonlySet<string>;
+}
+declare const EMPTY_SELECTION: SelectionState;
+declare function createSelection(ids?: Iterable<string>): SelectionState;
+declare function isSelected(state: SelectionState, id: string): boolean;
+declare function isSelectionEmpty(state: SelectionState): boolean;
+/** Selects or deselects one row. Without `selected`, flips it. */
+declare function toggleRow(state: SelectionState, id: string, selected?: boolean): SelectionState;
+/** A selection of exactly one row. */
+declare function selectOnly(id: string): SelectionState;
+/**
+ * Selects or deselects every row between two positions of `orderedIds`,
+ * inclusive and in either direction. This is the Shift+click behavior.
+ * Positions outside the list are clamped.
+ */
+declare function selectRange(state: SelectionState, orderedIds: readonly string[], from: number, to: number, selected?: boolean): SelectionState;
+/** Selects the given ids and nothing else. Use it when the grid knows every id. */
+declare function selectAll(ids: Iterable<string>): SelectionState;
+/** "Every row except none": the select-all of a grid that cannot list its ids. */
+declare function selectAllExceptNone(): SelectionState;
+declare function clearSelection(): SelectionState;
+/** How many rows are selected, given the total row count (needed in `exclude` mode). */
+declare function countSelected(state: SelectionState, total: number): number;
+type SelectionSummary = "none" | "some" | "all";
+/**
+ * The state of a select-all checkbox for a set of ids (the rows the checkbox
+ * stands for): `none`, `some` (indeterminate) or `all`.
+ */
+declare function summarizeSelection(state: SelectionState, ids: readonly string[]): SelectionSummary;
+/** The ids that are selected, given every id the grid has. */
+declare function resolveSelectedIds(state: SelectionState, allIds: Iterable<string>): string[];
+/** JSON-safe form, for storage or a URL. */
+interface SerializedSelection {
+    mode: "include" | "exclude";
+    ids: string[];
+}
+declare function serializeSelection(state: SelectionState): SerializedSelection;
+declare function deserializeSelection(value: SerializedSelection): SelectionState;
+
+/** Pinned column ids, in display order. `start` and `end` follow the reading direction. */
+interface ColumnPinning {
+    start: string[];
+    end: string[];
+}
+/**
+ * The part of the grid state a saved view keeps. Selection, expansion, paging
+ * and quick search are about the data on screen, not the view, and stay out.
+ */
+interface GridViewState {
+    sort: SortModelItem[];
+    filter: FilterModelItem[];
+    group: GroupModelItem[];
+    /** Column ids in display order. Ids missing here follow in definition order. */
+    columnOrder: string[];
+    /** `false` hides a column. A missing id is visible. */
+    columnVisibility: Record<string, boolean>;
+    /** Pixel widths of columns the user resized. */
+    columnSizing: Record<string, number>;
+    columnPinning: ColumnPinning;
+}
+/** The view a grid starts from, read from the column definitions (`hidden`, `pinned`). */
+declare function createViewState<Row>(columns: readonly ColumnDef<Row>[]): GridViewState;
+/** Known ids in the given order, then the rest in definition order. Duplicates and unknown ids drop out. */
+declare function resolveColumnOrder<Row>(columns: readonly ColumnDef<Row>[], order: readonly string[]): string[];
+/** The three zones of the grid, in display order. Hidden columns are left out. */
+interface ColumnLayout {
+    start: string[];
+    center: string[];
+    end: string[];
+}
+declare function layoutColumns<Row>(columns: readonly ColumnDef<Row>[], state: Pick<GridViewState, "columnOrder" | "columnVisibility" | "columnPinning">): ColumnLayout;
+/**
+ * The next sort model after the user activates a column header. A plain click
+ * replaces the model and cycles that column: ascending, descending, off. With
+ * `multi` (Shift+click) the column joins the model, or cycles inside it, and the
+ * other columns keep their rank.
+ */
+declare function toggleSort(sort: readonly SortModelItem[], field: string, multi?: boolean): SortModelItem[];
+/** Sets the direction of one column, or removes it with `null`. */
+declare function setSort(sort: readonly SortModelItem[], field: string, direction: SortDirection | null, multi?: boolean): SortModelItem[];
+/** The 1-based rank of a column in a multi-column sort, or `null` when it is not sorted. */
+declare function sortRank(sort: readonly SortModelItem[], field: string): number | null;
+/** Replaces the filter items of one column, or clears them with `null`. */
+declare function setColumnFilter(filter: readonly FilterModelItem[], field: string, item: FilterModelItem | null): FilterModelItem[];
+/** Adds the column to the group model, or removes it when it is already there. */
+declare function toggleGroup(group: readonly GroupModelItem[], field: string): GroupModelItem[];
+/** Pins a column to a side, or unpins it with `false`. A pinned column is appended to its side. */
+declare function setPinning(pinning: ColumnPinning, id: string, pin: ColumnPin | false): ColumnPinning;
+/**
+ * Moves a visible column one step earlier (`-1`) or later (`1`) inside its own
+ * zone: start-pinned, center or end-pinned. A column does not jump across
+ * pinning; use `setPinning` for that. Hidden columns are skipped over.
+ */
+declare function moveColumn<Row>(columns: readonly ColumnDef<Row>[], state: Pick<GridViewState, "columnOrder" | "columnVisibility" | "columnPinning">, id: string, delta: -1 | 1): Pick<GridViewState, "columnOrder" | "columnPinning">;
+/**
+ * Moves a visible column to just before or after another one: what dropping a
+ * dragged header does. Like `moveColumn` it stays inside its zone (start-pinned,
+ * center or end-pinned); a target in another zone changes nothing.
+ */
+declare function moveColumnTo<Row>(columns: readonly ColumnDef<Row>[], state: Pick<GridViewState, "columnOrder" | "columnVisibility" | "columnPinning">, id: string, targetId: string, placement: "before" | "after"): Pick<GridViewState, "columnOrder" | "columnPinning">;
+/** Sets the width of a column, clamped to its `minWidth` and `maxWidth`. */
+declare function resizeColumn<Row>(columns: readonly ColumnDef<Row>[], sizing: Readonly<Record<string, number>>, id: string, width: number): Record<string, number>;
+
+interface DelimitedOptions extends FormatContext {
+    /** Field separator. Defaults to `,` for CSV and a tab for TSV. */
+    delimiter?: string;
+    /** Row separator. Defaults to CRLF for CSV (RFC 4180) and LF for TSV. */
+    eol?: string;
+    /** Write the column headers as the first line. Default `true`. */
+    header?: boolean;
+    /**
+     * `formatted` writes what the grid shows ("$1,234.50", "Mar 5, 2024"); `raw`
+     * writes the stored value (1234.5, an ISO date). Default `formatted`.
+     */
+    values?: "formatted" | "raw";
+    /**
+     * Prefix cells that a spreadsheet would run as a formula (a leading `=`,
+     * `@`, tab, or a `+`/`-` that is not a plain number) with an apostrophe, so
+     * an exported cell cannot execute. Default `true` for CSV, `false` for TSV.
+     */
+    sanitizeFormulas?: boolean;
+    /** Write a UTF-8 byte order mark first, which Excel needs to read non-ASCII CSV. CSV only. */
+    bom?: boolean;
+}
+/** Quotes a field when it holds the delimiter, a quote or a line break. */
+declare function escapeDelimitedField(text: string, delimiter?: string): string;
+/** Escapes one CSV field per RFC 4180. */
+declare function escapeCsvField(text: string, delimiter?: string): string;
+/** Columns that hold data. `actions` columns carry buttons, not values. */
+declare function exportableColumns<Row>(columns: readonly ColumnDef<Row>[]): ColumnDef<Row>[];
+/**
+ * Serializes rows to CSV, one column per given column, in the given order.
+ * Pass the visible columns to export "the current view". Values go through the
+ * column formatters unless `values: "raw"`. Quotes, delimiters and line breaks
+ * are escaped, and formula-looking cells are neutralized. `actions` columns are
+ * skipped. The result has no trailing line break.
+ */
+declare function gridToCsv<Row>(rows: readonly Row[], columns: readonly ColumnDef<Row>[], options?: DelimitedOptions): string;
+/** Tab-separated text, the format spreadsheets paste. Used by "copy selection". */
+declare function gridToTsv<Row>(rows: readonly Row[], columns: readonly ColumnDef<Row>[], options?: DelimitedOptions): string;
+/** Reads CSV or TSV back into rows of text. Handles quoted fields, escaped quotes and line breaks. */
+declare function parseDelimited(text: string, delimiter?: string): string[][];
+
+/**
+ * Reads a saved view from untrusted JSON (storage, a URL, a server). Returns
+ * `null` when the value is not a view this version understands, so a bad or
+ * newer record is ignored instead of crashing the grid.
+ */
+declare function parseSavedView(value: unknown): SavedView | null;
+/** One saved view in a list, without loading its body. */
+interface SavedViewSummary {
+    id: string;
+    name?: string;
+}
+/**
+ * Where an app keeps saved views. The grid does not care: pass any
+ * implementation (local storage, your API, `@x12i/flowix-ui`'s Flowix adapter).
+ */
+interface SavedViewStore {
+    list(): Promise<SavedViewSummary[]>;
+    /** `null` when the id does not exist or holds something `parseSavedView` rejects. */
+    load(id: string): Promise<SavedView | null>;
+    save(id: string, view: SavedView): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+interface CaptureViewOptions {
+    name?: string;
+}
+/**
+ * Snapshots the view state into a `SavedView`. Columns are written in display
+ * order (start-pinned, center, end-pinned) with their width, `hidden` and `pinned`.
+ */
+declare function captureView<Row>(state: GridViewState, columns: readonly ColumnDef<Row>[], options?: CaptureViewOptions): SavedView;
+/**
+ * Turns a saved view back into view state for the given columns. Ids the grid
+ * does not have are ignored; columns the view does not mention keep their
+ * defaults and follow in definition order. The result never throws on a view
+ * saved against different columns, which is the normal case after a release.
+ */
+declare function applySavedView<Row>(view: SavedView, columns: readonly ColumnDef<Row>[]): GridViewState;
+/** A saved-view store that keeps views in memory. Handy for tests and demos. */
+declare function createMemorySavedViewStore(initial?: Record<string, SavedView>): SavedViewStore;
+/** The slice of `Storage` the local-storage store needs. */
+interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+interface LocalStorageSavedViewStoreOptions {
+    /** The key holding every view as one JSON object. Default `x12i-data-views`. */
+    key?: string;
+    /** Defaults to `localStorage`. Falls back to memory where there is none (SSR, private mode). */
+    storage?: StorageLike;
+}
+/**
+ * A saved-view store backed by `localStorage`, one JSON object under one key.
+ * Reads go through `parseSavedView`, so a corrupted or newer record is skipped.
+ */
+declare function createLocalStorageSavedViewStore(options?: LocalStorageSavedViewStoreOptions): SavedViewStore;
+
+/**
+ * Every user-facing string of the DataGrid and Pagination. Components contain
+ * no English: they read these. Templates use ICU MessageFormat (`{name}`,
+ * `{count, plural, one {# row} other {# rows}}`); see `formatMessage`.
+ */
+interface DataGridMessages {
+    loading: string;
+    loadingMore: string;
+    empty: string;
+    emptyFiltered: string;
+    error: string;
+    retry: string;
+    clearFilters: string;
+    toolbarLabel: string;
+    quickSearch: string;
+    quickSearchPlaceholder: string;
+    clearSearch: string;
+    columns: string;
+    columnsMenuLabel: string;
+    showAllColumns: string;
+    exportCsv: string;
+    copySelection: string;
+    copied: string;
+    copyFailed: string;
+    selectedCount: string;
+    allSelected: string;
+    clearSelection: string;
+    selectAll: string;
+    selectRow: string;
+    sortAscending: string;
+    sortDescending: string;
+    clearSort: string;
+    filterColumn: string;
+    columnMenu: string;
+    hideColumn: string;
+    pinStart: string;
+    pinEnd: string;
+    unpin: string;
+    moveEarlier: string;
+    moveLater: string;
+    groupBy: string;
+    ungroup: string;
+    resizeColumn: string;
+    sortRank: string;
+    filterOperator: string;
+    filterValue: string;
+    filterFrom: string;
+    filterTo: string;
+    filterApply: string;
+    filterClear: string;
+    filterAny: string;
+    filterNoOptions: string;
+    filterBlank: string;
+    operators: Record<FilterOperator, string>;
+    activeFilters: string;
+    filterSummary: string;
+    removeFilter: string;
+    clearAllFilters: string;
+    groupedBy: string;
+    removeGrouping: string;
+    expandRow: string;
+    collapseRow: string;
+    expandGroup: string;
+    collapseGroup: string;
+    groupLabel: string;
+    rowActions: string;
+    detailRegion: string;
+    totals: string;
+    yes: string;
+    no: string;
+    moreTags: string;
+    progressLabel: string;
+    editCell: string;
+    cellEditFailed: string;
+    cellSaved: string;
+    invalidNumber: string;
+    invalidDate: string;
+    announceSorted: string;
+    announceSortCleared: string;
+    announceFiltered: string;
+    announceFilterCleared: string;
+    announceGrouped: string;
+    announceColumnMoved: string;
+    announceColumnHidden: string;
+    announceColumnResized: string;
+    announcePinned: string;
+    announceSelection: string;
+    rowLoading: string;
+    rowFailed: string;
+    paginationLabel: string;
+    pageSize: string;
+    firstPage: string;
+    previousPage: string;
+    nextPage: string;
+    lastPage: string;
+    pageRange: string;
+    pageStatus: string;
+}
+type DataGridMessageOverrides = Partial<Omit<DataGridMessages, "operators">> & {
+    operators?: Partial<Record<FilterOperator, string>>;
+};
+/** The English messages. Pass a translated subset through the `messages` prop. */
+declare const defaultMessages: DataGridMessages;
+/** Merges overrides onto the English defaults. Missing keys keep their English text. */
+declare function resolveMessages(overrides?: DataGridMessageOverrides): DataGridMessages;
+
+export { deserializeSelection as $, EMPTY_SELECTION as E, applySavedView as O, captureView as P, clearSelection as Q, countSelected as R, createCellFormatter as T, createLocalStorageSavedViewStore as U, createMemorySavedViewStore as V, createSelection as W, createViewState as X, defaultFormatLabels as Y, defaultMessages as Z, defineColumns as _, escapeCsvField as a0, escapeDelimitedField as a1, exportableColumns as a2, formatCellValue as a3, gridToCsv as a4, gridToTsv as a5, isSelected as a6, isSelectionEmpty as a7, layoutColumns as a8, moveColumn as a9, moveColumnTo as aa, parseDelimited as ab, parseSavedView as ac, resizeColumn as ad, resolveColumnOrder as ae, resolveDateFormatOptions as af, resolveMessages as ag, resolveNumberFormatOptions as ah, resolveSelectedIds as ai, selectAll as aj, selectAllExceptNone as ak, selectOnly as al, selectRange as am, serializeSelection as an, setColumnFilter as ao, setPinning as ap, setSort as aq, sortRank as ar, summarizeSelection as as, toggleGroup as at, toggleRow as au, toggleSort as av, FILTER_OPERATORS as t, SAVED_VIEW_VERSION as y };
+export type { AggregateName as A, SavedViewStore as B, ColumnDef as C, DataGridMessageOverrides as D, FormatContext as F, GroupModelItem as G, SavedViewSummary as H, SelectionState as I, SelectionSummary as J, SerializedSelection as K, LocalStorageSavedViewStoreOptions as L, StatusTone as M, StorageLike as N, SortModelItem as S, CellType as a, ColumnAlign as b, ColumnEditor as c, ColumnFilterType as d, FilterOperator as e, FilterModelItem as f, SortDirection as g, GetRowsRequest as h, ServerDataSource as i, AggregateFn as j, CaptureViewOptions as k, CellFormatter as l, ColumnLayout as m, ColumnOption as n, ColumnPin as o, ColumnPinning as p, ColumnState as q, DataGridMessages as r, DelimitedOptions as s, FormatLabels as u, GetRowsOptions as v, GetRowsResult as w, GridViewState as x, SavedView as z };