@mono-lit/helper 0.0.0-stage → 0.0.2

package/dist/src/components/switch/mono-switch.shadow.d.ts

@@ -0,0 +1,36 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+declare const MonoSwitchShadow_base: import('../../composables/hybird-prop').Constructor<import('./switch-core.js').MonoSwitchCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-switch` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/switch`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`mono-switch`→`:host`). The
+ * track + thumb are pure CSS and the checked state is the `mono-switch-checked`
+ * wrapper class, so it server-renders from `this.checked` (no icons). The
+ * `label`/`description` slots carry the prop text as native fallback (shown
+ * server-side); presence is detected in `firstUpdated()` via `assignedNodes()`
+ * (DSD assigns at parse time → no `slotchange` after upgrade) + `@slotchange`
+ * for later changes. Interactivity needs the first client update to flush (so
+ * `@change` binds) — hence the defer-hydration poll. Shares all logic with the
+ * light build via `MonoSwitchCore`; both register `mono-switch`, so a document
+ * loads only one build.
+ */
+export declare class MonoSwitchShadow extends MonoSwitchShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _slotFor;
+    private _slotHasContent;
+    private _onSlotChange;
+    /**
+     * The sublabel region answers to `slot="sublabel"` and to the older
+     * `slot="description"` (nested inside it), so its presence is the union.
+     */
+    private _sublabelHasContent;
+    private _setSlotState;
+    /** Reconcile the 2 slot-presence flags from their slots' assigned content. */
+    private _scanSlots;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+export {};

package/dist/src/components/switch/switch-core.d.ts

@@ -0,0 +1,49 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { SwitchSize, SwitchColor, SwitchCssClass } from './switch-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoSwitchCoreInterface {
+    size: SwitchSize;
+    color: SwitchColor;
+    modelValue: boolean;
+    checked: boolean;
+    disabled: boolean;
+    loading: boolean;
+    label: string;
+    /** Secondary line under the label. */
+    sublabel: string;
+    /** The same as `sublabel`, kept for existing code. */
+    description: string;
+    value: string;
+    name: string;
+    ariaLabelText?: string;
+    cssClass: SwitchCssClass;
+    cssClassName: string;
+    focus(): void;
+    blur(): void;
+    protected _hasLabelSlotState: boolean;
+    protected _hasDescriptionSlotState: boolean;
+    protected _toBoolean(value: unknown): boolean;
+    protected _setCssClass(value: unknown): void;
+    protected _cls(base: string, key: keyof SwitchCssClass): string;
+    protected get _wrapperClasses(): string;
+    protected get _trackClasses(): string;
+    protected get _thumbClasses(): string;
+    protected _hasLabelContent(): boolean;
+    protected _hasDescriptionContent(): boolean;
+    protected _handleChange(event: Event): void;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+/**
+ * `MonoSwitchCore` — all render-mode-agnostic logic for `mono-switch`: reactive
+ * props (incl. SSR boolean coercion), hybrid aliases, camelCase attribute
+ * fallbacks, the `modelValue`↔`checked` sync, class computation, change
+ * interactivity (`mno-change`), `focus`/`blur`, AND the shared `render()`
+ * skeleton (`<label><input role=switch><track><thumb></track><labelBlock></label>`).
+ * The slot-bearing label/description region is an overridable hook
+ * (`_renderLabelBlock()`) that defaults to the light build's `[data-mono-slot]`
+ * placeholders; the shadow build overrides it with native `<slot>` (mirrors
+ * `mono-checkbox`). SSR-safe: no `document`/`window`; `focus`/`blur` query
+ * `this.renderRoot`.
+ */
+export declare const MonoSwitchCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoSwitchCoreInterface> & T;

package/dist/src/components/switch/switch-types.d.ts

@@ -0,0 +1,64 @@
+import { VisibilityProps } from '../../composables/visibility';
+export type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type SwitchColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export interface SwitchCssClass {
+    root?: string;
+    input?: string;
+    track?: string;
+    thumb?: string;
+    label?: string;
+    labelText?: string;
+    description?: string;
+}
+export type SwitchModelEventDetail = {
+    modelValue: boolean;
+    currentValue: boolean;
+    oldValue: boolean;
+    checked: boolean;
+    value?: string;
+    name?: string;
+    sourceEvent?: Event;
+};
+export type SwitchModelEvent = CustomEvent<SwitchModelEventDetail>;
+export interface SwitchProps extends VisibilityProps {
+    /** Two-way bound on/off state of the switch. */
+    modelValue?: boolean;
+    'model-value'?: boolean;
+    modelvalue?: boolean;
+    /** Whether the switch is checked (kept in sync with modelValue). */
+    checked?: boolean;
+    /** Color theme of the switch. */
+    color?: SwitchColor;
+    /** Size of the switch. */
+    size?: SwitchSize;
+    /** Disables interaction with the switch. */
+    disabled?: boolean;
+    /** Shows a loading state and blocks interaction. */
+    loading?: boolean;
+    /** Text label shown next to the switch. */
+    label?: string;
+    /** Secondary line under the label. `slot="sublabel"` replaces it. */
+    sublabel?: string;
+    /** The same as `sublabel` — still accepted, both names share one value. */
+    description?: string;
+    /** Value submitted with the form when checked. */
+    value?: string;
+    /** Form field name for the underlying input. */
+    name?: string;
+    /** Accessible label for screen readers. */
+    ariaLabelText?: string;
+    ariaLabel?: string;
+    'aria-label'?: string;
+    'aria-label-text'?: string;
+    arialabel?: string;
+    arialabeltext?: string;
+    /** Per-part class overrides for styling internal elements. */
+    cssClass?: SwitchCssClass;
+    cssclass?: SwitchCssClass;
+    'css-class'?: SwitchCssClass | string;
+}
+export interface SwitchEvents {
+    change: SwitchModelEvent;
+    'mno-change': SwitchModelEvent;
+    mnoChange: SwitchModelEvent;
+}

package/dist/src/components/switch/switch-utils.d.ts

@@ -0,0 +1,12 @@
+import { SwitchSize, SwitchColor } from './switch-types.js';
+/**
+ * Validate switch props
+ */
+export declare function validateSwitchProps(props: {
+    size?: SwitchSize;
+    color?: SwitchColor;
+}): boolean;
+/**
+ * Generate ARIA attributes for accessibility
+ */
+export declare function generateSwitchAttributes(disabled: boolean, loading: boolean, checked: boolean, label: string | undefined): Record<string, string | boolean | undefined>;

package/dist/src/components/table/array-source.d.ts

@@ -0,0 +1,44 @@
+import { MonoGridSource } from './mono-data-grid';
+import { MonoSearchValue } from '../../search/data-search';
+export interface MonoArraySourceOptions {
+    /** Rows per page (default 10). */
+    pageSize?: number;
+    /** Row key field for per-row `update` (default `'Id'`). */
+    keyExpr?: string;
+    /**
+     * Columns matched by `setSearch`, as an array or a comma-separated string.
+     *
+     * Same four interchangeable names as {@link monoDataGrid} — `searchValue`,
+     * `search-value`, `searchExpr`, `search-expr` — so a demo or app can spell it
+     * one way throughout. Plain column names and path expressions only: `*`
+     * patterns and `{ field, custom }` entries are resolved by the CONTROLLER, and
+     * it hands this source only `plainSearchColumns(...)`.
+     */
+    searchValue?: MonoSearchValue;
+    'search-value'?: MonoSearchValue;
+    /** Alias of {@link searchValue}, under devextreme's name. */
+    searchExpr?: MonoSearchValue;
+    'search-expr'?: MonoSearchValue;
+    /**
+     * Group-by field(s). When set, a grouped input payload (devextreme
+     * `type:'data'` shape) is flattened to its leaf records, so paging / search /
+     * sort all run over the underlying rows; {@link monoDataGrid} rebuilds the
+     * group tree per page.
+     */
+    group?: string | string[];
+}
+/**
+ * Wrap a plain array in the structural {@link MonoGridSource} shape so
+ * {@link monoDataGrid} can drive it with no devextreme DataSource — paging,
+ * search and filtering all run client-side, in memory.
+ *
+ * @example
+ * const source = monoArraySource(rows, { pageSize: 10, searchValue: ['name'] })
+ * const table = monoDataGrid(source)
+ * await table.load()
+ * // later: source.setData(nextRows)  // swap the underlying array
+ */
+export declare function monoArraySource<T = any>(data?: T[], opts?: MonoArraySourceOptions): MonoGridSource<T> & {
+    setData: (next: T[]) => Promise<T[]>;
+    update: (key: unknown, values: Record<string, unknown>) => Promise<T[]>;
+};

package/dist/src/components/table/date-filter-tree.d.ts

@@ -0,0 +1,93 @@
+import { MonoColumnValue } from './mono-data-grid.js';
+/** The levels of the tree, outermost first. */
+export type MonoDateLevel = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
+export declare const DATE_LEVELS: readonly MonoDateLevel[];
+/**
+ * A half-open period, `from` inclusive, `to` exclusive — the value shape a date
+ * filter stores on the column (`table.columnFilter(field)` returns these).
+ */
+export interface MonoDateRange {
+    from: Date;
+    to: Date;
+}
+/** A `{ from, to }` pair of Dates (or ISO strings, which `setColumnFilter` also accepts). */
+export declare function isDateRange(v: unknown): v is MonoDateRange | {
+    from: string;
+    to: string;
+};
+export interface DateNode {
+    /** Unique within the tree: the parts joined — `2026`, `2026-3`, `2026-3-5-13`… or `blank`. */
+    key: string;
+    level: MonoDateLevel;
+    /** `[year, month(1-12), day, hour, minute, second]` down to this level. */
+    parts: number[];
+    label: string;
+    /** Rows inside this period (summed from the timestamps it contains). */
+    count: number;
+    /** The period, `[from, to)`. `null` on the blanks node. */
+    from: Date | null;
+    to: Date | null;
+    children: DateNode[];
+}
+export interface DateTreeOptions {
+    /** Deepest level built. Default `'month'`. */
+    depth?: MonoDateLevel;
+    /** Read the parts in UTC instead of local time. Default `false`. */
+    utc?: boolean;
+    /** BCP-47 tag for the month / weekday names. Default: the browser's. */
+    locale?: string;
+}
+export declare const BLANK_KEY = "blank";
+/**
+ * A column value as a Date, or `null` for a blank / unparsable one. Accepts a
+ * `Date`, a number (epoch ms), an ISO string, and a bare `YYYY-MM-DD` — the
+ * last is parsed as a LOCAL date on purpose (`new Date('2026-03-05')` would be
+ * UTC midnight and shift a day west of Greenwich).
+ */
+export declare function parseDateValue(v: unknown): Date | null;
+/** `[year, month(1-12), day, hour, minute, second]` of a Date, local or UTC. */
+export declare function datePartsOf(d: Date, utc?: boolean): number[];
+/** The period `[from, to)` of a node at `level` with these parts. */
+export declare function periodOf(parts: number[], level: MonoDateLevel, utc?: boolean): MonoDateRange;
+/**
+ * Fold distinct timestamps into the tree. Only periods that occur are built,
+ * counts are summed up the branches, siblings are in chronological order, and
+ * a blank value becomes one `(Blanks)` node at the top (never expandable).
+ */
+export declare function buildDateTree(values: readonly MonoColumnValue[], options?: DateTreeOptions): DateNode[];
+export type CheckState = 'on' | 'off' | 'mixed';
+/**
+ * A node's tick state from the set of ticked keys. A key in the set means the
+ * WHOLE node is ticked (so every descendant is on too); otherwise the children
+ * decide — all on → on, none → off, some (or a partly-ticked child) → mixed.
+ *
+ * Pass `roots` to have a ticked ANCESTOR count (the node is then on) — the
+ * renderer walks top-down and passes `inheritedOn` instead, which is the same
+ * answer without a path lookup per row.
+ */
+export declare function checkState(node: DateNode, checked: ReadonlySet<string>, roots?: readonly DateNode[], inheritedOn?: boolean): CheckState;
+/**
+ * Tick or untick a node: the node's own key goes in (and every descendant key
+ * comes out — the node covers them) or the node and every descendant come out.
+ * Ticking a child of a fully-ticked parent first expands the parent's tick to its
+ * siblings, so unticking one day of a ticked month leaves the other days ticked.
+ */
+export declare function setChecked(node: DateNode, on: boolean, checked: ReadonlySet<string>, roots: readonly DateNode[]): Set<string>;
+/** Tick everything (every root) or nothing. */
+export declare function setAllChecked(roots: readonly DateNode[], on: boolean): Set<string>;
+/**
+ * The ticked periods as filter values — one `{ from, to }` per fully-ticked node,
+ * walking down only where a node is partly ticked. `(Blanks)` ticked adds a
+ * `null` value (the column filter's "is blank"), matching what the plain header
+ * filter sends for a blank.
+ */
+export declare function minimize(roots: readonly DateNode[], checked: ReadonlySet<string>): Array<MonoDateRange | null>;
+/**
+ * The tick set that reproduces an applied filter (`table.columnFilter(field)`):
+ * a node is ticked when one of the ranges covers its whole period; a blank value
+ * ticks `(Blanks)`. A range that only partly covers a node ticks the children it
+ * covers instead.
+ */
+export declare function seedFromRanges(roots: readonly DateNode[], values: readonly unknown[]): Set<string>;
+/** Whether a Date falls in `[from, to)`. */
+export declare function inRange(d: Date, r: MonoDateRange): boolean;

package/dist/src/components/table/grouping.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Client-side grouping helpers shared by {@link monoArraySource} and
+ * {@link monoDataGrid}. Dependency-free so @mono-lit/helper stays standalone; the
+ * tree shape mirrors what a devextreme DataSource produces for `group`, so a
+ * consumer can read `row.key` / `row.items[i].key` / … exactly as before.
+ */
+/**
+ * A node in the grouped tree. `key` / `items` match devextreme's grouped shape
+ * (leaf-level `items` are the raw records). The remaining fields are additive
+ * metadata for rendering and collapse state — they never shadow `key`/`items`.
+ */
+export interface MonoGroupNode<T = any> {
+    /** The group's key value (the row's value for this level's group field). */
+    key: unknown;
+    /** Child groups (deeper levels) or, at the innermost level, the leaf records. */
+    items: Array<MonoGroupNode<T> | T>;
+    /** Number of leaf records under this node. */
+    count: number;
+    /** Zero-based grouping depth. */
+    level: number;
+    /** Stable path key (e.g. `"Sales/CD001"`) — survives page/tree rebuilds. */
+    path: string;
+    /** Whether this node is currently collapsed in the UI. */
+    collapsed: boolean;
+    /**
+     * Server-side group metadata (only set in `serverGroup` mode): the group's
+     * total row `count` and any `aggregates` (e.g. a subtotal) from the groupby
+     * query — available without loading the group's rows.
+     */
+    meta?: {
+        key: unknown;
+        count: number;
+        aggregates?: Record<string, number>;
+    };
+}
+/** Duck-type a grouped node: `{ key, items: [...] }`. */
+export declare function isGroupNode(x: unknown): x is MonoGroupNode;
+/**
+ * Recursively collect the leaf records from a possibly-grouped array. Already
+ * flat rows pass straight through, so this safely normalises both a grouped
+ * payload (devextreme `type:'data'` with `group`) and a plain array.
+ */
+export declare function flattenLeaves<T = any>(rows: ReadonlyArray<MonoGroupNode<T> | T>): T[];
+/**
+ * Bucket flat leaf records into the nested {@link MonoGroupNode} tree by
+ * `fields` (in order). Group order follows first appearance in `rows` — the
+ * source group-orders the rows, so a paged slice renders contiguous headers.
+ *
+ * @param rows     Flat leaf records (already group-ordered for nice paging).
+ * @param fields   Group-by field names, outermost first.
+ * @param collapsed Set of collapsed `path`s; matching nodes get `collapsed:true`.
+ */
+export declare function buildGroups<T = any>(rows: ReadonlyArray<T>, fields: ReadonlyArray<string>, collapsed?: ReadonlySet<string>): Array<MonoGroupNode<T>>;
+/** Collect every group node's `path` from a built tree (for collapse-all). */
+export declare function collectGroupPaths<T = any>(nodes: ReadonlyArray<MonoGroupNode<T>>): string[];

package/dist/src/components/table/index.d.ts

@@ -0,0 +1,33 @@
+/// <reference path="../../../vue.d.ts" />
+export { monoDataGrid, controlMonoTable } from './mono-data-grid.js';
+export { setErrorMessages, resolveErrorMessages, describeError, errorStatus, normalizeError, DEFAULT_ERROR_MESSAGES } from '../../utils/normalize-error.js';
+export type { MonoErrorMessages, MonoErrorMessageKey, DescribedError } from '../../utils/normalize-error.js';
+export { monoArraySource } from './array-source.js';
+export type { MonoArraySourceOptions } from './array-source.js';
+export { isPath, parseFieldPath, getFieldValue, setFieldValue, mergePatch, toODataSelector, toODataClause, } from '../../search/field-path.js';
+export type { FieldSegment, ParsedFieldPath, ODataClause } from '../../search/field-path.js';
+export { buildGroups, flattenLeaves, isGroupNode, collectGroupPaths } from './grouping.js';
+export type { MonoGroupNode } from './grouping.js';
+export { expandWildcard, isWildcardPattern, normalizeSearchExpr, plainSearchColumns, resolveSearchEntries, } from '../../search/search-expr.js';
+export type { MonoSearchCustomCtx, MonoSearchCustomResult, MonoSearchExpr, MonoSearchExprCustom, MonoSearchExprEntry, ResolveSearchOptions, } from '../../search/search-expr.js';
+export { MonoTableSearch } from './mono-table-search.js';
+export { MonoTablePaging } from './mono-table-paging.js';
+export { MonoTablePagingGroup } from './mono-table-paging-group.js';
+export { MonoTablePageSize } from './mono-table-page-size.js';
+export { MonoTableInfo } from './mono-table-info.js';
+export { MonoTableSort } from './mono-table-sort.js';
+export { MonoTableTh } from './mono-table-th.js';
+export { MonoTableEmpty } from './mono-table-empty.js';
+export type { TableEmptyEvents, TableEmptyReloadEvent, TableEmptyReloadEventDetail, } from './mono-table-empty-core.js';
+export { MonoTableError } from './mono-table-error.js';
+export type { TableErrorEvents, TableErrorCloseEvent, TableErrorCloseEventDetail, TableErrorReloadEvent, TableErrorReloadEventDetail, } from './mono-table-error-core.js';
+export { MonoTableLoading } from './mono-table-loading.js';
+export { MonoTableSummary } from './mono-table-summary.js';
+export { MonoTableDetail } from './mono-table-detail.js';
+export type { TableDetailClickEvent, TableDetailClickEventDetail, TableDetailEvents, } from './mono-table-detail-core.js';
+export { MonoTableCheckbox } from './mono-table-checkbox.js';
+export type { TableCheckboxType, TableCheckboxChangeEvent, TableCheckboxChangeEventDetail, TableCheckboxEvents, } from './mono-table-checkbox-core.js';
+export type { SortOrder, GroupPageInfo, MonoDisplayRow, MonoGroupMeta, MonoServerGroupCtx, MonoServerGroupSource, MonoColumn, MonoColumnSort, MonoSetSortOptions, MonoSetColumnFilterOptions, MonoColumnValue, MonoSearchTerm, MonoEditableTrigger, MonoCellChange, MonoStagedChange, MonoGridStore, MonoFormConfig, MonoFormOp, MonoFormHandle, MonoStorePush, MonoSummaryType, MonoSummarySpec, MonoSummaryFieldSpec, MonoSummaryConfig, MonoSummaryRecalculate, MonoSummaryResult, MonoSummaryHandle, MonoColumnDef, MonoColumnHandle, MonoDetailEl, MonoDetailHandle, MonoCheckMode, MonoCheckConfig, MonoCheckHandle, } from './mono-data-grid.js';
+export type { MonoExportColumn, MonoExportFormat, MonoExportFormatOptions, MonoExportOptions, MonoExportResult, MonoExportStyle, MonoExportStyles, } from '../../export/types.js';
+export type { MonoImportAmbiguity, MonoImportChange, MonoImportColumn, MonoImportMatch, MonoImportNumberFormat, MonoImportOptions, MonoImportRejection, MonoImportResult, MonoImportType, MonoImportValueType, } from '../../import/types.js';
+export type { MonoTableController, MonoGridSource, MonoDataGridOptions, MonoDataSourceOptions, MonoOdataOptions, MonoDistinctValuesContext, TableSearchProps, TablePagingProps, TablePageSizeProps, TableInfoProps, TableSortProps, TableThProps, TableThSort, TableEmptyProps, TableErrorProps, TableLoadingProps, TableSummaryProps, TableDetailProps, TableCheckboxProps, } from './table-types.js';

package/dist/src/components/table/index.shadow.d.ts

@@ -0,0 +1,47 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoTableSearchShadow } from './mono-table-search.shadow.js';
+export { MonoTableSortShadow } from './mono-table-sort.shadow.js';
+export { MonoTablePagingShadow } from './mono-table-paging.shadow.js';
+export { MonoTablePagingGroupShadow } from './mono-table-paging-group.shadow.js';
+export { MonoTablePageSizeShadow } from './mono-table-page-size.shadow.js';
+export { MonoTableInfoShadow } from './mono-table-info.shadow.js';
+export { MonoTableThShadow } from './mono-table-th.shadow.js';
+export { MonoTableEmptyShadow } from './mono-table-empty.shadow.js';
+export { MonoTableErrorShadow } from './mono-table-error.shadow.js';
+export { MonoTableLoadingShadow } from './mono-table-loading.shadow.js';
+export { MonoTableSummaryShadow } from './mono-table-summary.shadow.js';
+export { MonoTableDetailShadow } from './mono-table-detail.shadow.js';
+export { MonoTableCheckboxShadow } from './mono-table-checkbox.shadow.js';
+export { MonoTableControllerCore } from './table-controller-core.js';
+export { MonoTableSearchCore } from './mono-table-search-core.js';
+export { MonoTableSortCore } from './mono-table-sort-core.js';
+export { MonoTablePagingCore } from './mono-table-paging-core.js';
+export { MonoTablePagingGroupCore } from './mono-table-paging-group-core.js';
+export { MonoTablePageSizeCore } from './mono-table-page-size-core.js';
+export { MonoTableInfoCore } from './mono-table-info-core.js';
+export { MonoTableThCore } from './mono-table-th-core.js';
+export { MonoTableEmptyCore } from './mono-table-empty-core.js';
+export { MonoTableErrorCore } from './mono-table-error-core.js';
+export { MonoTableLoadingCore } from './mono-table-loading-core.js';
+export { MonoTableSummaryCore } from './mono-table-summary-core.js';
+export { MonoTableDetailCore } from './mono-table-detail-core.js';
+export { MonoTableCheckboxCore } from './mono-table-checkbox-core.js';
+export type { TableCheckboxType, TableCheckboxChangeEvent, TableCheckboxChangeEventDetail, TableCheckboxEvents, } from './mono-table-checkbox-core.js';
+export type { TableDetailClickEvent, TableDetailClickEventDetail, TableDetailEvents, } from './mono-table-detail-core.js';
+export type { TableEmptyEvents, TableEmptyReloadEvent, TableEmptyReloadEventDetail, } from './mono-table-empty-core.js';
+export type { TableErrorEvents, TableErrorCloseEvent, TableErrorCloseEventDetail, TableErrorReloadEvent, TableErrorReloadEventDetail, } from './mono-table-error-core.js';
+export type { TableSearchIconName } from './mono-table-search-core.js';
+export type { TableSortSlotName, TableSortIconName } from './mono-table-sort-core.js';
+export type { TableThSlotName, TableThIconName, TableThAlign } from './mono-table-th-core.js';
+export { monoDataGrid } from './mono-data-grid.js';
+export { setErrorMessages, resolveErrorMessages, describeError, errorStatus, normalizeError, DEFAULT_ERROR_MESSAGES } from '../../utils/normalize-error.js';
+export type { MonoErrorMessages, MonoErrorMessageKey, DescribedError } from '../../utils/normalize-error.js';
+export { monoArraySource } from './array-source.js';
+export type { MonoArraySourceOptions } from './array-source.js';
+export { buildGroups, flattenLeaves, isGroupNode, collectGroupPaths } from './grouping.js';
+export type { MonoGroupNode } from './grouping.js';
+export { expandWildcard, isWildcardPattern, normalizeSearchExpr, plainSearchColumns, resolveSearchEntries, } from '../../search/search-expr.js';
+export type { MonoSearchCustomCtx, MonoSearchCustomResult, MonoSearchExpr, MonoSearchExprCustom, MonoSearchExprEntry, ResolveSearchOptions, } from '../../search/search-expr.js';
+export type { SortOrder, GroupPageInfo, MonoDisplayRow, MonoGroupMeta, MonoServerGroupCtx, MonoServerGroupSource, } from './mono-data-grid.js';
+export type { MonoColumn, MonoColumnSort, MonoColumnValue, MonoSearchTerm, MonoEditableTrigger, MonoCellChange, MonoStagedChange, MonoGridStore, MonoSummaryType, MonoSummarySpec, MonoSummaryFieldSpec, MonoSummaryConfig, MonoSummaryRecalculate, MonoSummaryResult, MonoSummaryHandle, MonoColumnDef, MonoColumnHandle, MonoDetailEl, MonoDetailHandle, MonoCheckMode, MonoCheckConfig, MonoCheckHandle, } from './mono-data-grid.js';
+export type { MonoTableController, MonoGridSource, MonoDataGridOptions, TableSearchProps, TablePagingProps, TablePageSizeProps, TableInfoProps, TableSortProps, TableThProps, TableThSort, TableEmptyProps, TableErrorProps, TableLoadingProps, TableSummaryProps, TableDetailProps, TableCheckboxProps, } from './table-types.js';