@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-web-ui/src/CommandPalette/CommandPalette.d.ts

@@ -2,51 +2,24 @@ import React from 'react';
 export interface CommandPaletteItem {
     id: string;
     label: React.ReactNode;
-    /** Plain text used for searching — set when `label` is a node. */
     searchText?: string;
-    /** Extra terms to match on: synonyms, the old name for a screen. */
     keywords?: string;
-    /** Group heading. Items keep the order they arrive in within a group. */
     section?: string;
     icon?: React.ReactNode;
-    /** Trailing hint — a shortcut, a route. */
     hint?: React.ReactNode;
     disabled?: boolean;
 }
 export interface CommandPaletteProps {
-    /** Already filtered and authorised by the caller — this component renders, it does not decide. */
     items: CommandPaletteItem[];
     open: boolean;
     onOpenChange: (open: boolean) => void;
     onSelect: (item: CommandPaletteItem) => void;
-    /**
-     * Global shortcut, matched case-insensitively with ctrl OR meta. `null` disables it so the
-     * host can own the binding. Default `'k'`.
-     */
     hotkey?: string | null;
     placeholder?: string;
     emptyMessage?: React.ReactNode;
-    /** Shown before anything is typed. Omit to show all items. */
     initialItems?: CommandPaletteItem[];
-    /** Cap on rendered results. Default 50. */
     maxResults?: number;
     'aria-label'?: string;
 }
-/**
- * The generic half of a command palette: the shortcut, the dialog, the search box, a grouped
- * result list and its keyboard model. **It decides nothing about what is in the list** —
- * building items from a route registry and filtering them by permission is app logic and stays
- * in the app.
- *
- * Built on pieces that already exist rather than a new dependency:
- * - `Dialog` for the overlay, focus trap, Escape and top-layer stacking.
- * - `popupList.module.css` for rows and group headings, so a palette row and a Select option
- *   are the same object visually.
- * - `fuseSearch`, already used by Suggest, so fuzzy matching behaves the same across the
- *   library and `fuse.js` — already a declared dependency — is the only cost.
- *
- * This is what replaced `cmdk` in the client's version: a fourth list implementation with its
- * own dependency, its own styling and its own keyboard behaviour.
- */
 declare const CommandPalette: React.FC<CommandPaletteProps>;
 export default CommandPalette;

package/dist/types/shared-web-ui/src/DataTable/DataTable.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type DataTableProps } from './types';
+import './DataTable.grid.css';
+import './DataTable.css';
+import './DataTable.container.css';
+import './DataTable.features.css';
+import './DataTable.layouts.css';
+export declare function sameSorting(a: Array<{
+    id: string;
+    desc: boolean;
+}>, b: Array<{
+    id: string;
+    desc: boolean;
+}>): boolean;
+declare function DataTable<TData = any>({ data: dataProp, views, tableId, className, dataSource, persistence: persistenceProp, authorize, exportOptions, initialState: initialStateProp, onStateChange, onRowsChange, apiRef, bulkActions: tableBulkActions, labels: labelsProp, locale, renderDetail: tableRenderDetail, detailBar, openRowId: openRowIdProp, onOpenRowChange, shortcuts: tableShortcutsProp, sharing, renamedViews, prefsVersion, migratePrefs, title, }: DataTableProps<TData>): React.JSX.Element;
+export default DataTable;

package/dist/types/shared-web-ui/src/DataTable/DisplayPopover.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { type DataTableDisplayPrefs } from './types';
+interface DisplayPopoverProps {
+    settings: DataTableDisplayPrefs;
+    onChange: (settings: DataTableDisplayPrefs) => void;
+    devToolsSupported?: boolean;
+    devToolsEnabled?: boolean;
+    onDevToolsChange?: (enabled: boolean) => void;
+    actionsFor?: 'table' | 'card';
+    shortcutsHint?: boolean;
+    pageSize?: {
+        options: {
+            name: string;
+            value: string;
+        }[];
+        value: string;
+        onChange: (value: string) => void;
+    };
+    summaryOffered?: boolean;
+}
+declare const DisplayPopover: React.FC<DisplayPopoverProps>;
+export default DisplayPopover;

package/dist/types/shared-web-ui/src/DataTable/HeaderMenu.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import type { PinSide } from './pinning';
+import type { DataTableColumn } from './types';
+export interface HeaderMenuState {
+    columnKey: string;
+    x: number;
+    y: number;
+    alignRight?: boolean;
+}
+interface HeaderMenuProps {
+    state: HeaderMenuState;
+    column: DataTableColumn | undefined;
+    header: string;
+    canSort: boolean;
+    canFilter: boolean;
+    canHide: boolean;
+    pinnedSide: PinSide | null;
+    canPin: boolean;
+    onSort: (desc: boolean) => void;
+    onFilter: () => void;
+    onPin: (side: PinSide | null) => void;
+    onAutoFit: () => void;
+    onHide: () => void;
+    onClose: () => void;
+    groupBy?: {
+        grouped: boolean;
+        onToggle: () => void;
+    };
+}
+export declare function HeaderMenu(p: HeaderMenuProps): React.JSX.Element;
+export default HeaderMenu;

package/dist/types/shared-web-ui/src/DataTable/ManageModal.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { type DataTableView, type DataTableManagePrefs, type DataTableColumn, type DataTableExportSummaryMode, type DataTableSummaryPrefs, type DataTableSummaryStrip } from './types';
+import { type SummaryLayout } from './summary/summaryCatalogue';
+export interface ViewManageDraft {
+    summary: DataTableSummaryPrefs | undefined;
+    strips: Record<DataTableSummaryStrip, boolean>;
+    templates: Record<string, {
+        summary?: DataTableExportSummaryMode;
+        summaryCards?: string[];
+    }>;
+}
+export interface ManageViewsHost {
+    summaryOffered: (view: DataTableView) => boolean;
+    layoutOf: (view: DataTableView, prefs: DataTableSummaryPrefs | undefined) => SummaryLayout;
+    columnsOf: (view: DataTableView) => DataTableColumn[];
+    breakdownColumnsOf: (view: DataTableView) => DataTableColumn[];
+    load: (view: DataTableView) => Promise<ViewManageDraft>;
+    defaults: (view: DataTableView) => ViewManageDraft;
+    save: (drafts: Map<DataTableView, ViewManageDraft>) => void;
+}
+interface ManageModalProps {
+    configs: DataTableView[];
+    prefs: DataTableManagePrefs;
+    maxVisible: number;
+    onChange: (next: DataTableManagePrefs) => void;
+    onClose: () => void;
+    initialViewId?: string;
+    views: ManageViewsHost;
+}
+declare const ManageModal: React.FC<ManageModalProps>;
+export default ManageModal;

package/dist/types/shared-web-ui/src/DataTable/SingleRowView.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type DataTableSingleRowView, type DataTableColumn } from './types';
+interface TableSingleDataViewProps {
+    row: any;
+    config: DataTableSingleRowView;
+    columns: DataTableColumn[];
+}
+declare const SingleRowView: React.FC<TableSingleDataViewProps>;
+export default SingleRowView;

package/dist/types/shared-web-ui/src/DataTable/SortModal.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type DataTableColumn } from './types';
+interface SortModalProps {
+    sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>;
+    setSorting: (sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>) => void;
+    columns: DataTableColumn[];
+    onClose: () => void;
+}
+declare const SortModal: React.FC<SortModalProps>;
+export default SortModal;

package/dist/types/shared-web-ui/src/DataTable/StatusRow.d.ts

@@ -0,0 +1,49 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableLabels } from './labels';
+import type { DataTableActiveFilter, DataTableBulkAction, DataTableColumn } from './types';
+export interface StatusRowBulkButton {
+    action: DataTableBulkAction;
+    disabledReason?: string;
+}
+interface StatusRowProps {
+    selecting: boolean;
+    bulkButtons: StatusRowBulkButton[];
+    busyActionId?: string | null;
+    onRunBulkAction: (action: DataTableBulkAction) => void;
+    selectedCount: number;
+    allMatching: boolean;
+    selectAll?: {
+        label: string;
+        onClick: () => void;
+    };
+    onClearSelection: () => void;
+    sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>;
+    setSorting: (sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>) => void;
+    columns: DataTableColumn[];
+    activeFilters: DataTableActiveFilter[];
+    removeFilter: (id: string) => void;
+    onClearAll: () => void;
+    onOpenFilters: () => void;
+    groupChips?: ReactNode;
+    selectionText?: string;
+    summary?: string;
+    defaultOrder?: {
+        text: string;
+        title: string;
+    };
+    summaryChips?: ReadonlyMap<string, string>;
+}
+export declare function sortWords(col: DataTableColumn | undefined, desc: boolean, L: DataTableLabels): string;
+export declare function chipText(f: DataTableActiveFilter, L: DataTableLabels): {
+    label: string;
+    sep: string;
+    value: string;
+};
+declare const StatusRow: React.FC<StatusRowProps>;
+export default StatusRow;

package/dist/types/shared-web-ui/src/DataTable/TableColumnModal.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type DataTableColumn, type DataTableDisplayPrefs, type DataTableColumnPinning } from './types';
+interface TableColumnModalProps {
+    columns: DataTableColumn[];
+    columnOrder: string[];
+    setColumnOrder: (order: string[]) => void;
+    columnVisibility: Record<string, boolean>;
+    setColumnVisibility: (vis: Record<string, boolean>) => void;
+    resetColumns: () => void;
+    pinning?: DataTableColumnPinning;
+    onPinningChange?: (pinning: DataTableColumnPinning) => void;
+    onClose: () => void;
+    hasActions?: boolean;
+    displayPrefs?: DataTableDisplayPrefs;
+    onDisplayPrefsChange?: (settings: DataTableDisplayPrefs) => void;
+}
+declare const TableColumnModal: React.FC<TableColumnModalProps>;
+export default TableColumnModal;

package/dist/types/shared-web-ui/src/DataTable/TableControls.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+interface TableIconButtonProps {
+    icon: React.ReactNode;
+    onClick: () => void;
+    disabled?: boolean;
+    title?: string;
+    'aria-label'?: string;
+    'aria-pressed'?: boolean;
+    'aria-expanded'?: boolean;
+    'aria-haspopup'?: 'menu' | 'dialog' | 'listbox';
+    'aria-keyshortcuts'?: string;
+    className?: string;
+}
+export declare const TableIconButton: React.ForwardRefExoticComponent<TableIconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+interface TableButtonProps {
+    label: string;
+    onClick: () => void;
+    icon?: React.ReactNode;
+    variant?: 'default' | 'tonal';
+    disabled?: boolean;
+    className?: string;
+}
+export declare const TableButton: React.FC<TableButtonProps>;
+interface TableSelectOption {
+    name: string;
+    value: string;
+}
+interface TableSelectProps {
+    options: TableSelectOption[];
+    value: string;
+    onChange: (value: string) => void;
+    className?: string;
+    ariaLabel?: string;
+}
+export declare const TableSelect: React.FC<TableSelectProps>;
+interface TableInputProps {
+    type?: string;
+    value: string;
+    onChange: (value: string) => void;
+    onBlur?: () => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    min?: number;
+    max?: number;
+    className?: string;
+    ariaLabel?: string;
+}
+export declare const TableInput: React.FC<TableInputProps>;
+export {};

package/dist/types/shared-web-ui/src/DataTable/TablePagination.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { type DataTablePaginationConfig } from './types';
+export declare const ALL_PAGE_SIZE = "-1";
+export interface TablePager {
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+    setPageIndex: (i: number) => void;
+    setPageSize: (n: number) => void;
+}
+export declare function pagerOf(table: any, pager?: TablePager): TablePager;
+export declare function pageSizeChoices(paginationConfig: DataTablePaginationConfig, allMode: boolean, pageSize: number, formatNumber: (n: number) => string, allLabel: string): {
+    options: {
+        name: string;
+        value: string;
+    }[];
+    value: string;
+};
+export declare function changePageSize(pager: TablePager, setAllMode: (v: boolean) => void, val: string): void;
+export declare function PageSizeSelect({ options, value, onChange }: {
+    options: {
+        name: string;
+        value: string;
+    }[];
+    value: string;
+    onChange: (value: string) => void;
+}): React.JSX.Element;
+interface TablePaginationProps {
+    table: any;
+    pager?: TablePager;
+    paginationConfig: DataTablePaginationConfig;
+    allMode: boolean;
+    setAllMode: (val: boolean) => void;
+    variant?: 'full' | 'compact' | 'phone';
+}
+declare const TablePagination: React.FC<TablePaginationProps>;
+export default TablePagination;

package/dist/types/shared-web-ui/src/DataTable/TableScrollStrip.d.ts

@@ -0,0 +1,2 @@
+import { type ScrollStripProps } from '../Scroll';
+export declare function TableScrollStrip(props: Omit<ScrollStripProps, 'labels'>): import("react").JSX.Element;

package/dist/types/shared-web-ui/src/DataTable/TableToolbar.d.ts

@@ -0,0 +1,69 @@
+import React, { type ReactNode } from 'react';
+import { type DataTableActiveFilter, type DataTableColumnPinning, type DataTableDisplayPrefs, type DataTableQuickFilter, type DataTableQuickFilterMode, type DataTableSavedFilter, type DataTableLayout } from './types';
+interface TableToolbarProps {
+    phone: boolean;
+    searchEnabled: boolean;
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+    rowInfo?: string;
+    filteringEnabled: boolean;
+    activeFilters: DataTableActiveFilter[];
+    filterGroup: any;
+    setFilterGroup: (group: any) => void;
+    filterModalOpen: boolean;
+    setFilterModalOpen: (open: boolean) => void;
+    filterRowOffered?: boolean;
+    filterRowVisible?: boolean;
+    onToggleFilterRow?: () => void;
+    quickFilters?: DataTableQuickFilter[];
+    quickFilterCounts?: Record<string, number>;
+    quickFilterMode?: DataTableQuickFilterMode;
+    quickFilterLabel?: string;
+    activeQuickFilterIds: string[];
+    onQuickFilterChange: (ids: string[]) => void;
+    savedFilters?: DataTableSavedFilter[];
+    onSaveFilter?: (preset: DataTableSavedFilter) => void;
+    onDeleteFilter?: (id: string) => void;
+    showSelectButton: boolean;
+    selecting: boolean;
+    onToggleSelecting: () => void;
+    layouts: DataTableLayout[];
+    layout: DataTableLayout;
+    onLayoutChange: (layout: DataTableLayout) => void;
+    columnsOffered: boolean;
+    onOpenFields?: () => void;
+    expandAll?: {
+        expanded: boolean;
+        onToggle: () => void;
+    };
+    groupNode?: ReactNode;
+    sortingEnabled: boolean;
+    exportNode?: ReactNode;
+    columnModalOpen: boolean;
+    setColumnModalOpen: (open: boolean) => void;
+    sortModalOpen: boolean;
+    setSortModalOpen: (open: boolean) => void;
+    columns: any[];
+    sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>;
+    sortChanged: boolean;
+    setSorting: (sorting: Array<{
+        id: string;
+        desc: boolean;
+    }>) => void;
+    columnOrder: string[];
+    setColumnOrder: (order: string[]) => void;
+    columnVisibility: Record<string, boolean>;
+    setColumnVisibility: (vis: Record<string, boolean>) => void;
+    resetColumns: () => void;
+    pinning?: DataTableColumnPinning;
+    onPinningChange?: (pinning: DataTableColumnPinning) => void;
+    hasActions?: boolean;
+    displayPrefs: DataTableDisplayPrefs;
+    onDisplayPrefsChange: (settings: DataTableDisplayPrefs) => void;
+    table: any;
+}
+declare const TableToolbar: React.FC<TableToolbarProps>;
+export default TableToolbar;

package/dist/types/shared-web-ui/src/DataTable/TableView.d.ts

@@ -0,0 +1,61 @@
+import React, { type ReactNode } from 'react';
+import { type DataTableView, type DataTableDisplayPrefs, type DataTableActiveFilter, type DataTableColumnPinning, type DataTableFilterGroup } from './types';
+import { type CellChange } from './useDataChangeTracker';
+import { type PinSide } from './pinning';
+import { type RowPressHandlers } from './rows/rowPress';
+import type { DisplayItem } from './grouping/groupModel';
+import { type ScrollApi, type VirtualOptions } from './virtual/useVirtualLines';
+export interface TableFilterRowProps {
+    visible: boolean;
+    filterGroup: DataTableFilterGroup;
+    setFilterGroup: (group: DataTableFilterGroup) => void;
+    debounceMs: number;
+}
+interface TableViewProps {
+    table: any;
+    config: DataTableView;
+    checkboxes: boolean;
+    toggleRowSelection: (rowId: string) => void;
+    toggleAllRowsSelection: () => void;
+    isAllRowsSelected: boolean;
+    isSomeRowsSelected: boolean;
+    onColumnHide?: (columnId: string) => void;
+    onColumnFilter?: (columnId: string, anchor: HTMLElement) => void;
+    activeFilters?: DataTableActiveFilter[];
+    filteringEnabled?: boolean;
+    changedCells?: Map<string, Map<string, CellChange>>;
+    rowKey?: string;
+    displayPrefs?: DataTableDisplayPrefs;
+    error?: unknown;
+    onRetry?: () => void;
+    serverMode?: boolean;
+    rowsQueryKey?: string;
+    press: (row: any) => RowPressHandlers;
+    clickable: boolean;
+    openRowId?: string | null;
+    renderActions?: (row: any) => ReactNode;
+    hasActionColumn: boolean;
+    pinning?: DataTableColumnPinning;
+    onPinColumn?: (columnKey: string, side: PinSide | null) => void;
+    pinSelection?: boolean;
+    pinActions?: boolean;
+    filterRow?: TableFilterRowProps;
+    items?: DisplayItem[];
+    grouped?: boolean;
+    renderGroupLine?: (item: DisplayItem, place: 'table') => ReactNode;
+    keyboard?: {
+        activeKey: string | null;
+        activeCol: number;
+        rowIndexBase: number;
+        rowCount: number;
+    };
+    grouping?: {
+        canGroup: (columnKey: string) => boolean;
+        isGrouped: (columnKey: string) => boolean;
+        onGroup: (columnKey: string, on: boolean) => void;
+    };
+    virtual?: VirtualOptions | null;
+    scrollApi?: React.MutableRefObject<ScrollApi | null>;
+}
+declare const TableView: React.FC<TableViewProps>;
+export default TableView;

package/dist/types/shared-web-ui/src/DataTable/bulk/BulkConfirmDialog.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { DataTableBulkAction, DataTableBulkConfirm } from '../types';
+import { type BulkPlan } from './bulkActions';
+interface BulkConfirmDialogProps<T> {
+    action: DataTableBulkAction<T>;
+    confirm: DataTableBulkConfirm;
+    plan: BulkPlan<T>;
+    busy: boolean;
+    onConfirm: (input: string | undefined) => void;
+    onClose: () => void;
+}
+export declare function BulkConfirmDialog<T>({ action, confirm, plan, busy, onConfirm, onClose }: BulkConfirmDialogProps<T>): React.JSX.Element;
+export default BulkConfirmDialog;

package/dist/types/shared-web-ui/src/DataTable/bulk/TableToast.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface TableToastState {
+    id: number;
+    text: string;
+    status: 'success' | 'warning' | 'error';
+    undo?: () => void;
+    timeoutMs: number;
+}
+export declare function TableToast({ toast, onDismiss }: {
+    toast: TableToastState | null;
+    onDismiss: () => void;
+}): React.ReactPortal | null;
+export default TableToast;

package/dist/types/shared-web-ui/src/DataTable/bulk/bulkActions.d.ts

@@ -0,0 +1,23 @@
+import type { DataTableAuthorize, DataTableBulkAction, DataTableBulkActionResult, DataTableBulkConfirm, DataTableSelection, DataTableView } from '../types';
+import type { TableFormat, DataTableLabels } from '../labels';
+export declare function resolveBulkActions<T>(global: DataTableBulkAction<T>[] | undefined, view: Pick<DataTableView<T>, 'bulkActions' | 'hideBulkActions'>, viewKey: string, authorize?: DataTableAuthorize): DataTableBulkAction<T>[];
+export interface BulkPlan<T> {
+    rows: T[];
+    skipped: Array<{
+        row: T;
+        reason: string;
+    }>;
+    count: number;
+    disabledReason?: string;
+}
+export declare function planBulkAction<T>(action: DataTableBulkAction<T>, selection: DataTableSelection<T>, labels: DataTableLabels, fmt: TableFormat): BulkPlan<T>;
+export declare function resolveConfirm<T>(action: DataTableBulkAction<T>, plan: BulkPlan<T>, selection: DataTableSelection<T>): DataTableBulkConfirm | null;
+export declare function summarizeReasons(skipped: Array<{
+    reason: string;
+}>, fmt: TableFormat, withCounts?: boolean): string;
+export interface BulkSummary {
+    text: string;
+    status: 'success' | 'warning' | 'error';
+}
+export declare const bulkResultOf: (returned: DataTableBulkActionResult | void) => DataTableBulkActionResult | undefined;
+export declare function summarizeBulkResult<T>(plan: BulkPlan<T>, result: DataTableBulkActionResult | undefined, labels: DataTableLabels, fmt: TableFormat): BulkSummary;

package/dist/types/shared-web-ui/src/DataTable/cards/CardFieldsEditor.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DataTableColumn } from '../types';
+import { type FieldSet, type Fields } from './cardFields';
+import { type AvatarOption } from './rowParts';
+interface FieldsEditorProps<T, K extends string> {
+    set: FieldSet<K>;
+    columns: DataTableColumn<T>[];
+    fields: Fields<K>;
+    defaults: Fields<K>;
+    sampleRow?: T;
+    avatar?: AvatarOption<T>;
+    onSave: (fields: Fields<K>) => void;
+    onClose: () => void;
+}
+export declare function CardFieldsEditor<T, K extends string>({ set, columns, fields: initial, defaults, sampleRow, avatar, onSave, onClose }: FieldsEditorProps<T, K>): React.JSX.Element;
+export default CardFieldsEditor;

package/dist/types/shared-web-ui/src/DataTable/cards/CardView.d.ts

@@ -0,0 +1,50 @@
+import React, { type ReactNode } from 'react';
+import type { RowPressHandlers } from '../rows/rowPress';
+import type { ListParts, RowParts } from './rowParts';
+import { type ScrollApi, type VirtualOptions } from '../virtual/useVirtualLines';
+export interface CardRow {
+    id: string;
+    parts: RowParts;
+    list: ListParts | null;
+    selected: boolean;
+    selectable: boolean;
+}
+export type CardLine = {
+    kind: 'row';
+    key: string;
+    row: CardRow;
+} | {
+    kind: 'line';
+    key: string;
+    node: ReactNode;
+    level: number;
+    expanded?: boolean;
+};
+export interface MotionOptions {
+    enabled: boolean;
+    resetKey: string | undefined;
+}
+interface CardViewProps {
+    rows: CardRow[];
+    lines?: CardLine[];
+    checkboxes: boolean;
+    onToggle: (id: string) => void;
+    press: (id: string) => RowPressHandlers;
+    renderActions: (id: string) => ReactNode;
+    allExpanded: boolean;
+    minCardWidth?: number;
+    focusable: boolean;
+    activeKey?: string | null;
+    placeholder?: ReactNode;
+    loading?: boolean;
+    virtual?: VirtualOptions | null;
+    scrollApi?: React.MutableRefObject<ScrollApi | null>;
+    motion?: MotionOptions;
+}
+export declare function CardContent({ parts, open }: {
+    parts: RowParts;
+    open: boolean;
+}): React.JSX.Element;
+export declare function cardsPerLine(width: number, minCard: number, gap?: number): number;
+export declare function CardView({ rows, lines: linesProp, checkboxes, onToggle, press, renderActions, allExpanded, minCardWidth, focusable, activeKey, placeholder, loading, virtual, scrollApi, motion }: CardViewProps): React.JSX.Element;
+export default CardView;

package/dist/types/shared-web-ui/src/DataTable/cards/cardFields.d.ts

@@ -0,0 +1,32 @@
+import { type DataTableCardField, type DataTableCardFields, type DataTableColumn, type DataTableListField, type DataTableListFields } from '../types';
+export interface FieldSet<K extends string> {
+    kind: 'card' | 'list';
+    parts: readonly K[];
+    limits: Readonly<Record<K, number>>;
+    addTo: readonly K[];
+}
+export type Fields<K extends string> = Record<K, string[]>;
+export declare const CARD_FIELD_SET: FieldSet<DataTableCardField>;
+export declare const LIST_FIELD_SET: FieldSet<DataTableListField>;
+export declare function isFieldsOf<K extends string>(set: FieldSet<K>, value: unknown): value is Partial<Fields<K>>;
+export declare function normalizeFields<K extends string>(set: FieldSet<K>, raw: Partial<Fields<K>> | undefined, columns: DataTableColumn[]): Fields<K>;
+export declare function sameFields<K extends string>(set: FieldSet<K>, a: Fields<K>, b: Fields<K>): boolean;
+export declare function unplacedColumns<K extends string>(set: FieldSet<K>, fields: Fields<K>, columns: DataTableColumn[]): DataTableColumn[];
+export declare function placeField<K extends string>(set: FieldSet<K>, fields: Fields<K>, key: string, part: K | null, opts?: {
+    replace?: boolean;
+}): Fields<K>;
+export declare function partForAdd<K extends string>(set: FieldSet<K>, fields: Fields<K>): K | null;
+export declare const isCardFields: (value: unknown) => value is Partial<DataTableCardFields>;
+export declare const normalizeCardFields: (raw: Partial<DataTableCardFields> | undefined, columns: DataTableColumn[]) => DataTableCardFields;
+export declare function defaultCardFields(columns: DataTableColumn[], configured?: Partial<DataTableCardFields>): DataTableCardFields;
+export declare const isListFields: (value: unknown) => value is Partial<DataTableListFields>;
+export declare const normalizeListFields: (raw: Partial<DataTableListFields> | undefined, columns: DataTableColumn[]) => DataTableListFields;
+export declare function defaultListFields(columns: DataTableColumn[], configured: Partial<DataTableListFields> | undefined, card: DataTableCardFields): DataTableListFields;
+export interface CellTextLabels {
+    yes: string;
+    no: string;
+}
+export declare function cellText(column: DataTableColumn, row: unknown, labels: CellTextLabels): string;
+export declare function valueText(column: DataTableColumn, value: unknown, labels: CellTextLabels): string;
+export declare function initialsOf(text: string): string;
+export declare function hueOf(text: string): number;