@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/{shared-web-ui/src → components}/ChipInput/useChipSuggestions.d.ts

@@ -1,2 +1,2 @@
-import type { UseChipSuggestionsOptions, UseChipSuggestionsReturn } from '../../../published/dcs-ui/src/publicTypes';
+import type { UseChipSuggestionsOptions, UseChipSuggestionsReturn } from '../../core/types';
 export declare function useChipSuggestions({ sources, searchTerm, syntax, }: UseChipSuggestionsOptions): UseChipSuggestionsReturn;

package/dist/types/{shared-web-ui/src → components}/Collapsible/Collapsible.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { CollapsibleProps } from '../../../published/dcs-ui/src/publicTypes';
+import { CollapsibleProps } from '../../core/types';
 declare const Collapsible: React.FC<CollapsibleProps>;
 export default Collapsible;

package/dist/types/{shared-web-ui/src → components}/Collapsible/CollapsibleContext.d.ts

@@ -1,3 +1,3 @@
-import { CollapsibleContextValue } from '../../../published/dcs-ui/src/publicTypes';
+import { CollapsibleContextValue } from '../../core/types';
 export declare const CollapsibleContext: import("react").Context<CollapsibleContextValue | null>;
 export declare const useCollapsibleContext: () => CollapsibleContextValue;

package/dist/types/{shared-web-ui/src → components}/Collapsible/CollapsibleItem.d.ts

@@ -1,8 +1,6 @@
 import React from 'react';
-import { CollapsibleItemProps } from '../../../published/dcs-ui/src/publicTypes';
-/** Marks the triggers that arrow-key navigation moves focus between. */
+import { CollapsibleItemProps } from '../../core/types';
 export declare const TRIGGER_ATTR = "data-collapsible-trigger";
-/** Scopes that navigation to one accordion. */
 export declare const ROOT_ATTR = "data-collapsible-root";
 export declare const CollapsibleItem: React.FC<CollapsibleItemProps>;
 export default CollapsibleItem;

package/dist/types/{shared-web-ui/src → components}/Collapsible/index.d.ts

@@ -1,4 +1,4 @@
 export { default as Collapsible } from './Collapsible';
 export { CollapsibleItem } from './CollapsibleItem';
 export { CollapsibleContext, useCollapsibleContext } from './CollapsibleContext';
-export type { CollapsibleProps, CollapsibleItemProps, CollapsibleContextValue, CollapsibleVariant, CollapsibleSize, CollapsibleColor, CollapsibleIconPosition, CollapsibleExpansionMode, CollapsibleAuthorize, } from '../../../published/dcs-ui/src/publicTypes';
+export type { CollapsibleProps, CollapsibleItemProps, CollapsibleContextValue, CollapsibleVariant, CollapsibleSize, CollapsibleColor, CollapsibleIconPosition, CollapsibleExpansionMode, CollapsibleAuthorize, } from '../../core/types';

package/dist/types/components/ColorSchemeSelect/ColorSchemeSelect.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { SelectProps } from '../../core/types';
+import { ColorScheme } from '../../core/logic';
+export interface ColorSchemeSelectProps extends Omit<SelectProps, 'options' | 'renderOption' | 'renderSelectedValue'> {
+    schemes: ColorScheme[];
+    sampleTitle?: string;
+    sampleLabel?: string;
+    noneLabel?: string;
+}
+declare const ColorSchemeSelect: React.FC<ColorSchemeSelectProps>;
+export default ColorSchemeSelect;

package/dist/types/components/CommandPalette/CommandPalette.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface CommandPaletteItem {
+    id: string;
+    label: React.ReactNode;
+    searchText?: string;
+    keywords?: string;
+    section?: string;
+    icon?: React.ReactNode;
+    hint?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface CommandPaletteProps {
+    items: CommandPaletteItem[];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (item: CommandPaletteItem) => void;
+    hotkey?: string | null;
+    placeholder?: string;
+    emptyMessage?: React.ReactNode;
+    initialItems?: CommandPaletteItem[];
+    maxResults?: number;
+    'aria-label'?: string;
+}
+declare const CommandPalette: React.FC<CommandPaletteProps>;
+export default CommandPalette;

package/dist/types/components/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/components/DataTable/DataTable.storyData.d.ts

@@ -0,0 +1,23 @@
+import { type DataTableColumn, type DataTableDataSource, type DataTableSummaryCard } from './types';
+export interface Order {
+    id: string;
+    number: string;
+    customer: string;
+    product: string;
+    category: 'Furniture' | 'Lighting' | 'Kitchen' | 'Garden' | 'Office';
+    region: 'North' | 'South' | 'East' | 'West';
+    status: 'New' | 'Packed' | 'Shipped' | 'Delivered' | 'Returned';
+    qty: number;
+    amount: number;
+    paid: boolean;
+    ordered: string;
+}
+export declare function makeOrders(count?: number, seed?: number): Order[];
+export declare const ORDERS: Order[];
+export declare const money: (n: number) => string;
+export declare const orderColumns: DataTableColumn<Order>[];
+export declare const orderSummaryCards: DataTableSummaryCard<Order>[];
+export declare function fakeOrderServer(rows?: Order[], opts?: {
+    latency?: number;
+    fail?: boolean;
+}): DataTableDataSource<Order>;

package/dist/types/components/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/components/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/components/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/components/DataTable/PressButton.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const PressButton: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & React.RefAttributes<HTMLButtonElement>>;

package/dist/types/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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/components/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;