@ai-matrx/design-system 0.21.14 → 0.25.0

package/dist/{types-BgqIKbhq.d.cts → types-CmQrOz-T.d.cts}

@@ -1,6 +1,10 @@
 import { ContentTransferReference } from './content-transfer.cjs';
 import { ReactNode } from 'react';
 import { AiVariant, AiCustomSource, CopyExportConfig } from './data-table/copy-types.cjs';
+import { F as FieldFormatConfig } from './types-CJWU1Gae.cjs';
+import { GroupAggregateSpec, GroupOrder } from './data-table/grouping.cjs';
+import { CellPatch } from './data-table/fill.cjs';
+import { SpreadsheetIntent } from './data-table/spreadsheet.cjs';
 
 type TableSearchRole = "id" | "name" | "description" | "other";
 interface TableSearchScope {
@@ -80,6 +84,151 @@ declare function columnFiltersToLayeredRules(filters: ColumnFiltersState, fieldI
 declare function layeredFilterMatchesValue(value: unknown, rule: LayeredFilterRule): boolean;
 declare function layeredFilterRuleSummary(rule: LayeredFilterRule, fields: readonly LayeredFilterField[]): string;
 
+/**
+ * Table style — colors on a user data table, the Airtable way.
+ *
+ * WHAT IS ALLOWED, AND WHY ONLY THIS. A typed dataset is not a canvas; the
+ * platform already has Workbooks (Univer) for arbitrary per-cell formatting.
+ * Here, color carries MEANING and stays out of the data:
+ *
+ *   1. COLOR BY A COLUMN — a choice column's option colors (or a boolean's
+ *      true/false) tint the row or that column's cells. Zero configuration:
+ *      the Status column already knows "Blocked" is red.
+ *   2. RULES — "when Amount > 1000, tint the row amber". Evaluated live, so a
+ *      tint is never stale.
+ *   3. MANUAL HIGHLIGHTS — a small palette on a cell, a row, or a column, for
+ *      the "look at this one" gesture. The same palette the choice chips use,
+ *      so the table never has two vocabularies of color.
+ *
+ * WHERE IT LIVES. This module is the MODEL only — pure, no React, no DOM, no
+ * network. Each consumer names its own home for the same document and writes it
+ * surgically BY PATH (`stylePath.*`), so two editors highlighting different
+ * cells never overwrite each other:
+ *
+ *   - user data tables (`/data`): `udt_datasets.metadata.style`, written by
+ *     `public.udt_set_table_style(p_table_id, p_path, p_value)`.
+ *   - the record store: the table's saved view / Table settings document,
+ *     written by `custom.table_style_set(p_table, p_path, p_value)`.
+ *
+ * Copy, export, agents and the data itself never see the style.
+ *
+ * PRECEDENCE (most deliberate wins): a manual cell highlight > a cell rule >
+ * color-by targeting cells > a manual column highlight, for the CELL; a manual
+ * row highlight > a row rule > color-by targeting rows, for the ROW. A cell
+ * tint always paints over the row tint underneath it.
+ *
+ * Pure module: no React, no DOM, no Supabase.
+ */
+declare const TABLE_STYLE_VERSION: 1;
+/**
+ * The highlight palette.
+ *
+ * These are the SAME seven names the choice-chip palette uses minus "neutral"
+ * (which means "no color"), spelled out here so the model carries no import at
+ * all. Names, never raw hex: a name is legible on both grounds because each one
+ * ships its own `dark:` class below, and a retired name degrades to "no color"
+ * instead of to an unreadable swatch. A consumer that also draws choice chips
+ * must keep its chip palette on these names, or the table grows two vocabularies
+ * of color.
+ */
+declare const STYLE_COLORS: readonly ["slate", "green", "amber", "red", "blue", "violet", "teal"];
+type StyleColor = (typeof STYLE_COLORS)[number];
+declare function isStyleColor(v: unknown): v is StyleColor;
+declare const COLOR_RULE_OPS: readonly ["is", "is_not", "contains", "is_empty", "not_empty", "is_true", "is_false", "gt", "gte", "lt", "lte"];
+type ColorRuleOp = (typeof COLOR_RULE_OPS)[number];
+/** Which ops take a value to compare against. */
+declare const OPS_WITH_VALUE: readonly ColorRuleOp[];
+declare const COLOR_RULE_OP_LABELS: Record<ColorRuleOp, string>;
+type StyleTarget = "row" | "cell";
+type ColorRule = {
+    id: string;
+    /** Machine field name the condition reads. */
+    field: string;
+    op: ColorRuleOp;
+    /** Compared as text for `is` / `is_not` / `contains`, as a number for gt/lt. */
+    value?: string;
+    color: StyleColor;
+    /** Tint the whole row, or only this column's cell. */
+    target: StyleTarget;
+};
+type ColorBy = {
+    field: string;
+    target: StyleTarget;
+};
+type TableStyle = {
+    version: typeof TABLE_STYLE_VERSION;
+    colorBy?: ColorBy | null;
+    rules?: ColorRule[];
+    /** Manual row highlights, by row id. */
+    rows?: Record<string, StyleColor>;
+    /** Manual cell highlights, by row id then field name. */
+    cells?: Record<string, Record<string, StyleColor>>;
+    /** Manual column highlights, by field name. */
+    columns?: Record<string, StyleColor>;
+};
+declare const EMPTY_TABLE_STYLE: TableStyle;
+/** The conventional key the style document lives under on a table's own metadata. */
+declare const TABLE_STYLE_METADATA_KEY = "style";
+/** True when nothing in the style would paint anything. */
+declare function tableStyleIsEmpty(style: TableStyle): boolean;
+/**
+ * Read a style off table metadata. Tolerant by design: an unknown key, a
+ * retired color name or a malformed rule is dropped, never thrown, because a
+ * table must still render when its style is stale.
+ */
+declare function parseTableStyle(raw: unknown): TableStyle;
+/** Style out of a table-metadata blob (or null / undefined). */
+declare function tableStyleFromMetadata(metadata: unknown): TableStyle;
+/** Does `value` satisfy `rule`? Text ops compare case-insensitively; number ops parse both sides. */
+declare function evaluateRule(rule: ColorRule, value: unknown): boolean;
+/**
+ * The color a choice / boolean column gives a value, for color-by. The caller
+ * supplies the lookup because option colors live on the resolved choice list
+ * (which may come from a structured list), not on the style.
+ */
+type ChoiceColorLookup = (fieldName: string, value: unknown) => StyleColor | undefined;
+/**
+ * The color an option paints with. An option that DECLARED a color uses it; an
+ * option without one gets a stable color from its position in the list, so
+ * "color rows by Status" always paints something — Airtable assigns every
+ * option a color for the same reason. A column whose options were never
+ * colored would otherwise look like color-by did nothing at all.
+ */
+declare function colorForChoice(choices: readonly {
+    value: string;
+    color?: string;
+}[] | undefined, value: unknown): StyleColor | undefined;
+/**
+ * Boolean columns have no option list; color-by paints true green and leaves
+ * false untinted, which is the "done / not done" reading every checklist has.
+ */
+declare const BOOLEAN_TRUE_COLOR: StyleColor;
+/** The tint for a whole row, or null for none. */
+declare function resolveRowColor(style: TableStyle, row: {
+    id: string;
+    data: Record<string, unknown>;
+}, choiceColorFor: ChoiceColorLookup): StyleColor | null;
+/** The tint for one cell (painted over the row tint), or null for none. */
+declare function resolveCellColor(style: TableStyle, row: {
+    id: string;
+    data: Record<string, unknown>;
+}, fieldName: string, choiceColorFor: ChoiceColorLookup): StyleColor | null;
+declare const ROW_TINT_CLASS: Record<StyleColor, string>;
+declare const CELL_TINT_CLASS: Record<StyleColor, string>;
+/** A solid swatch for palette menus. */
+declare const SWATCH_CLASS: Record<StyleColor, string>;
+declare const STYLE_COLOR_LABELS: Record<StyleColor, string>;
+type StylePath = readonly string[];
+declare const stylePath: {
+    colorBy: () => StylePath;
+    rules: () => StylePath;
+    row: (rowId: string) => StylePath;
+    cell: (rowId: string, fieldName: string) => StylePath;
+    column: (fieldName: string) => StylePath;
+};
+/** Apply a path write locally, so the grid repaints before the round trip returns. */
+declare function applyStylePath(style: TableStyle, path: StylePath, value: unknown): TableStyle;
+
 /** How a column's filter UI behaves. `auto` infers from sample values. */
 type ColumnFilterKind = "auto" | "text" | "select" | "boolean" | "number" | false;
 type SortDirection = "asc" | "desc";
@@ -259,6 +408,36 @@ interface MatrxColumnDef<T> {
         /** Force non-navigable for this column. */
         forbidden?: boolean | ((id: string, row: T) => boolean);
     };
+    /**
+     * How this column's value READS — money, percent, a date style, decimal
+     * places. The vocabulary is the platform's one field-format registry
+     * (`@ai-matrx/design-system/field-formats`), the same `{id, options}` a user
+     * data table stores on its column and the record store stores on its Field,
+     * so `$1,234.56` is the same `$1,234.56` on every table in the product.
+     *
+     * A declarative format, not another render function, because a `cell`
+     * callback is invisible to everything else: with `format` the column also
+     * right-aligns itself, and a consumer's own `cell` asks the primitive for the
+     * same text through `formatColumnValue(col, value)` rather than growing a
+     * second money formatter beside this one.
+     *
+     * THE FALLBACK LAW travels with it: a value that does not fit the declared
+     * format is never blanked and never throws — it renders its base-type text in
+     * amber with the reason on hover, so the person SEES the mismatch.
+     *
+     * `cell` still wins when both are set.
+     */
+    format?: FieldFormatConfig;
+    /**
+     * Keep this column in place while the rest of the table scrolls sideways.
+     *
+     * Only the LEADING RUN freezes, only from `sm:` up, and only when the widths
+     * the offsets need are known — `./frozen-columns.ts` says why each of those
+     * three is a rule and not a default. Give a frozen column an explicit
+     * `width`; without one the table declines to freeze anything rather than pin
+     * a column at a guessed offset.
+     */
+    frozen?: boolean;
     className?: string;
     headerClassName?: string;
     width?: string | number;
@@ -579,6 +758,17 @@ interface TableViewSnapshot {
         hidden: string[];
         widths?: Record<string, number>;
     };
+    /**
+     * The view's COLORS — color-by-a-column, rules, and manual highlights
+     * (`./table-style.ts`). Optional so every view saved before colors existed
+     * still parses; absent means "this view paints nothing".
+     *
+     * Colors belong to the VIEW and not to the data, for the same reason the
+     * filters do: two people can read one table two ways, and neither reading is
+     * a fact about the records. That is also why this snapshot is the only place
+     * a style is carried — copy, export and agents read the rows, never this.
+     */
+    style?: TableStyle;
 }
 /** Host port for durable named views. The host owns actor, tenancy and CRUD. */
 interface TableSavedViewsProps {
@@ -855,6 +1045,157 @@ interface MatrxDataTableMobileCardControls {
     expandedDetail: ReactNode;
 }
 type MatrxDataTableDensity = "condensed" | "normal" | "spacious";
+/**
+ * What the table needs in order to paint a `TableStyle` itself.
+ *
+ * `fieldOf` exists because a style names DATA fields ("tint the row when
+ * `status` is Blocked") while the table addresses COLUMNS. In the common case
+ * the column id IS the field name and the default is right; a table whose
+ * column ids are decorated (`records-grid-notes`) maps them here.
+ */
+interface MatrxDataTableStyleConfig<T> {
+    /** The style document. */
+    style: TableStyle;
+    /** The row's data as the rules read it. Defaults to the row itself. */
+    documentOf?: (row: T) => Record<string, unknown>;
+    /** Column id to the field name a rule would name. Defaults to identity. */
+    fieldOf?: (columnId: string) => string;
+    /**
+     * The color a choice column's option paints with, for color-by. The consumer
+     * supplies it because option colors live on the resolved option list, which
+     * may come from a shared pick list this package cannot reach.
+     */
+    choiceColorFor?: ChoiceColorLookup;
+}
+/**
+ * GROUPING — "group these rows by Status" with collapsible sections, a count
+ * and a subtotal on each.
+ *
+ * This is the primitive's answer to the biggest gap against Airtable, Google
+ * Sheets and Notion. It is opt-in, and it is CONTROLLED for the two pieces of
+ * state a person expects to survive: which column groups, and which sections
+ * are shut. Both are ordinary values, so a saved view carries them like any
+ * other reading of the table.
+ *
+ * Grouping runs AFTER local processing and over the rows the table is about to
+ * render. It never re-sorts inside a group: the sort the person chose is the
+ * order they see.
+ */
+interface MatrxDataTableGroupingConfig<T> {
+    /** Column id to group by. `null` means grouping is available but off. */
+    columnId: string | null;
+    /** Emitted when the person picks a different column (or clears it). */
+    onColumnIdChange?: ((columnId: string | null) => void) | undefined;
+    /**
+     * Columns offered in the group-by control. Defaults to every visible column
+     * that is not an actions column. A column with thousands of distinct values
+     * is a bad grouping and the consumer is the only one who knows that.
+     */
+    groupableColumnIds?: string[] | undefined;
+    /** Per-column subtotal shown on every group header, keyed by column id. */
+    aggregates?: Record<string, GroupAggregateSpec> | undefined;
+    /** Controlled collapsed group keys (`TableGroup.key`). */
+    collapsed?: string[] | undefined;
+    onCollapsedChange?: ((collapsed: string[]) => void) | undefined;
+    /** Section order. Default `"value-asc"`; blanks always sort last. */
+    order?: GroupOrder | undefined;
+    /** Label for the section of rows whose grouping value is blank. */
+    emptyLabel?: string | undefined;
+    /** Singular noun for a group's summary ("job" → "12 jobs"). */
+    rowNoun?: string | undefined;
+    /**
+     * Reads the grouping value for a column. Defaults to the column's own
+     * accessor.
+     *
+     * NOT named `valueOf`: every object in JavaScript already has one, so an
+     * optional config field by that name is always "present" and a `config.valueOf
+     * ? … : …` check silently calls `Object.prototype.valueOf` and groups every
+     * row under the config object itself. It did exactly that here once.
+     */
+    readCell?: ((row: T, columnId: string) => unknown) | undefined;
+}
+/**
+ * VIRTUALIZATION — render the rows a person can actually see.
+ *
+ * Off by default, because most tables in the product are short and a windowed
+ * body costs a scroll container contract that a short table does not need.
+ * On, it engages only past `threshold` rows, so a 40-row table behaves exactly
+ * as it always did and a 100,000-row table scrolls.
+ */
+interface MatrxDataTableVirtualizeConfig {
+    enabled?: boolean | undefined;
+    /** Row height in px used for the window math. Default follows density. */
+    rowHeight?: number | undefined;
+    /** Rows rendered beyond each edge of the viewport. Default 8. */
+    overscan?: number | undefined;
+    /** Row count below which the body renders whole. Default 150. */
+    threshold?: number | undefined;
+    /**
+     * Window the COLUMNS too, for tables hundreds of columns wide. Frozen
+     * columns are always rendered, never windowed out.
+     */
+    columns?: boolean | undefined;
+    /** Column width in px used for the horizontal window. Default 160. */
+    columnWidth?: number | undefined;
+}
+/**
+ * THE HONEST COUNT.
+ *
+ * A table that filters over part of its rows and says nothing is a screen that
+ * lies. Declare what the answer actually covers and the table states it, in
+ * plain English, above the rows — and never presents a partial count as exact.
+ *
+ * Omit this entirely and the table says nothing, which is correct for a table
+ * whose rows are all in hand.
+ */
+interface MatrxDataTableCoverageConfig {
+    /** Rows the source says match the current query, when it can say. */
+    matched?: number | undefined;
+    /** Rows in the table irrespective of the query, when known. */
+    total?: number | undefined;
+    /** A ceiling the source imposed on this answer (a fetch cap). */
+    cap?: number | undefined;
+    /** Who answered the filters and sort. Default `"client"`. */
+    answeredBy?: "source" | "client" | undefined;
+    /** Singular noun for the sentence. Default "row". */
+    noun?: string | undefined;
+}
+/**
+ * SPREADSHEET GESTURES — range selection, Excel paste, fill, undo.
+ *
+ * The `/data` grid had all of this and nothing else in the product could reach
+ * it. Opt-in, because a reference table with one editable column does not want
+ * a cell cursor; a table a person works IN does.
+ *
+ * The table owns the gestures and the selection rectangle; the CONSUMER owns
+ * the writes. Every mutation arrives as a list of `CellPatch`, so the caller
+ * applies it through the door it already has and the table never invents a
+ * persistence path of its own. That is also what makes undo honest: the stack
+ * holds before-values, and an undo is just another patch list.
+ */
+interface MatrxDataTableSpreadsheetConfig<T> {
+    enabled?: boolean | undefined;
+    /**
+     * Apply cell writes. Called for a paste, a fill-down, a fill-handle drag, a
+     * clear, an undo and a redo. The table re-reads from `data`, so a write the
+     * caller refuses simply never appears.
+     */
+    onPatch: (patches: CellPatch[], intent: SpreadsheetIntent) => void | Promise<void>;
+    /** Column ids a patch may target. Defaults to every column marked `editable`. */
+    writableColumnIds?: string[] | undefined;
+    /** Why a column refuses a write, as a sentence a person can act on. */
+    columnRefusal?: ((columnId: string) => string | undefined) | undefined;
+    /** Reads a cell for copy and fill. Defaults to the column's own accessor. */
+    readCell?: ((row: T, columnId: string) => unknown) | undefined;
+    /** The little square at the corner of a selection. Default true. */
+    fillHandle?: boolean | undefined;
+    /** Paste real Excel/Sheets TSV into the selection. Default true. */
+    paste?: boolean | undefined;
+    /** Undo depth. 0 turns undo off. Default 100. */
+    undoDepth?: number | undefined;
+    /** Says what just happened, and why something did not. */
+    notify?: ((message: string) => void) | undefined;
+}
 interface MatrxDataTableProps<T> {
     data: T[];
     columns: MatrxColumnDef<T>[];
@@ -964,6 +1305,46 @@ interface MatrxDataTableProps<T> {
     footerRows?: T[];
     /** Per-row presentation class, after canonical selection/highlight state. */
     rowClassName?: (row: T, index: number) => string | undefined;
+    /**
+     * Per-CELL presentation class, after the column's own static `className`.
+     *
+     * The primitive had `rowClassName` and a static per-column `className`, and
+     * nothing in between — so every table that needed to say something about ONE
+     * cell had to grow a `cell` render function and paint inside it, where the
+     * table can no longer see it. This is the missing rung, and `tableStyle`
+     * below is the declarative thing built on top of it.
+     */
+    cellClassName?: (row: T, columnId: string, index: number) => string | undefined;
+    /**
+     * COLORS, declaratively — color by a column, rules, manual highlights.
+     *
+     * The model is `./table-style.ts`: one document, evaluated live on every
+     * render so a tint is never stale, with a documented precedence between the
+     * three ways a cell can earn a color. Pass the document and the table paints
+     * itself; the consumer owns only where that document is STORED and how a
+     * person edits it.
+     */
+    tableStyle?: MatrxDataTableStyleConfig<T>;
+    /**
+     * GROUPS — collapsible sections by a column, with a count and per-column
+     * subtotals on each header. Opt-in and controlled; see the config's own doc.
+     */
+    grouping?: MatrxDataTableGroupingConfig<T>;
+    /** Render only the rows in view. Opt-in; engages past its own threshold. */
+    virtualize?: boolean | MatrxDataTableVirtualizeConfig;
+    /**
+     * What the current answer actually covers. Declare it and the table says so
+     * on screen when a filter is answering over part of the table, instead of
+     * presenting a partial count as the whole truth.
+     */
+    coverage?: MatrxDataTableCoverageConfig;
+    /** Range selection, Excel paste, fill handle, fill-down, undo. Opt-in. */
+    spreadsheet?: MatrxDataTableSpreadsheetConfig<T>;
+    /**
+     * Explicit body row height in px. Overrides the density default. Use it when
+     * a saved view remembers a row height the person chose.
+     */
+    rowHeight?: number;
     /** Highlight an index in the currently rendered page without selecting it. */
     highlightedIndex?: number | undefined;
     /** Receives the complete visible local view after local processing, before paging. Attaching after absence receives one snapshot; callback identity changes alone do not notify. */
@@ -1029,4 +1410,4 @@ interface MatrxDataTableProps<T> {
     onRowOpen?: (row: T) => void;
 }
 
-export { isLayeredFilterOperator as $, type AnyOfColumnSearch as A, type MatrxDataTableWindowConfig as B, type ColumnFiltersState as C, type MatrxTablePagination as D, type SortDirection as E, type TableRankedSearchOptions as F, type TableSearchRole as G, type TableSearchScope as H, type TableViewQuery as I, type TextFilterMode as J, type ToolbarFacet as K, type LayeredFilterRule as L, type MatrxColumnDef as M, inferTableSearchRole as N, rankTableSearchRows as O, resolveTableSearchScopes as P, LAYERED_FILTER_OPERATORS as Q, LAYERED_FILTER_OPERATOR_LABELS as R, type SortState as S, type TableSearchMatchMode as T, type LayeredFilterField as U, type LayeredFilterOperator as V, columnFiltersToLayeredRules as W, completeLayeredFilterRules as X, decodeLayeredFilterRules as Y, encodeLayeredFilterRules as Z, isCompleteLayeredFilterRule as _, type ColumnFilterValue as a, layeredFilterMatchesValue as a0, layeredFilterNeedsValue as a1, layeredFilterRuleSummary as a2, operatorsForLayeredField as a3, type TableSavedViewsProps as b, type MatrxDataTableRecordControls as c, type MatrxDataTableDensity as d, type MatrxDataTableQueryState as e, type ColumnFilterKind as f, type MatrxDataTableCopyConfig as g, type MatrxDataTableProps as h, type TableViewSnapshot as i, type ColumnMarker as j, type CellEditType as k, type CellEditsMap as l, type MatrxDataTableContextMenuConfig as m, type MatrxDataTableDetailConfig as n, type MatrxDataTableEditConfig as o, type MatrxDataTableEmptyState as p, type MatrxDataTableExpandedDetailConfig as q, type MatrxDataTableFilterUi as r, type MatrxDataTableHierarchyConfig as s, type MatrxDataTableHierarchyMove as t, type MatrxDataTableMobileCardControls as u, type MatrxDataTableQueryControl as v, type MatrxDataTableSelectionConfig as w, type MatrxDataTableSourceProcessing as x, type MatrxDataTableToolbar as y, type MatrxDataTableUrlStateConfig as z };
+export { type SortDirection as $, type AnyOfColumnSearch as A, BOOLEAN_TRUE_COLOR as B, type ColumnFiltersState as C, type MatrxDataTableGroupingConfig as D, EMPTY_TABLE_STYLE as E, type MatrxDataTableHierarchyConfig as F, type MatrxDataTableHierarchyMove as G, type MatrxDataTableMobileCardControls as H, type MatrxDataTableQueryControl as I, type MatrxDataTableSelectionConfig as J, type MatrxDataTableSourceProcessing as K, type LayeredFilterRule as L, type MatrxColumnDef as M, type MatrxDataTableSpreadsheetConfig as N, type MatrxDataTableStyleConfig as O, type MatrxDataTableToolbar as P, type MatrxDataTableUrlStateConfig as Q, type MatrxDataTableVirtualizeConfig as R, type SortState as S, type TableSearchMatchMode as T, type MatrxDataTableWindowConfig as U, type MatrxTablePagination as V, OPS_WITH_VALUE as W, ROW_TINT_CLASS as X, STYLE_COLORS as Y, STYLE_COLOR_LABELS as Z, SWATCH_CLASS as _, type ColumnFilterValue as a, type StyleColor as a0, type StylePath as a1, type StyleTarget as a2, TABLE_STYLE_METADATA_KEY as a3, TABLE_STYLE_VERSION as a4, type TableRankedSearchOptions as a5, type TableSearchRole as a6, type TableSearchScope as a7, type TableStyle as a8, type TableViewQuery as a9, layeredFilterNeedsValue as aA, layeredFilterRuleSummary as aB, operatorsForLayeredField as aC, type TextFilterMode as aa, type ToolbarFacet as ab, applyStylePath as ac, colorForChoice as ad, evaluateRule as ae, inferTableSearchRole as af, isStyleColor as ag, parseTableStyle as ah, rankTableSearchRows as ai, resolveCellColor as aj, resolveRowColor as ak, resolveTableSearchScopes as al, stylePath as am, tableStyleFromMetadata as an, tableStyleIsEmpty as ao, LAYERED_FILTER_OPERATORS as ap, LAYERED_FILTER_OPERATOR_LABELS as aq, type LayeredFilterField as ar, type LayeredFilterOperator as as, columnFiltersToLayeredRules as at, completeLayeredFilterRules as au, decodeLayeredFilterRules as av, encodeLayeredFilterRules as aw, isCompleteLayeredFilterRule as ax, isLayeredFilterOperator as ay, layeredFilterMatchesValue as az, type TableSavedViewsProps as b, type MatrxDataTableRecordControls as c, type MatrxDataTableDensity as d, type MatrxDataTableQueryState as e, type ColumnFilterKind as f, type MatrxDataTableCopyConfig as g, type MatrxDataTableProps as h, type TableViewSnapshot as i, type ColumnMarker as j, CELL_TINT_CLASS as k, COLOR_RULE_OPS as l, COLOR_RULE_OP_LABELS as m, type CellEditType as n, type CellEditsMap as o, type ChoiceColorLookup as p, type ColorBy as q, type ColorRule as r, type ColorRuleOp as s, type MatrxDataTableContextMenuConfig as t, type MatrxDataTableCoverageConfig as u, type MatrxDataTableDetailConfig as v, type MatrxDataTableEditConfig as w, type MatrxDataTableEmptyState as x, type MatrxDataTableExpandedDetailConfig as y, type MatrxDataTableFilterUi as z };