@dcs-tech/ui 0.2.0 → 0.4.0

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

package/dist/types/components/DataTable/cards/rowParts.d.ts

@@ -0,0 +1,38 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableCardFields, DataTableColumn, DataTableListFields, DataTableView } from '../types';
+import { type CellTextLabels } from './cardFields';
+export interface RowField {
+    key: string;
+    header: string;
+    node: ReactNode;
+}
+export interface RowParts {
+    title: string;
+    titleKey?: string;
+    subtitle: string;
+    subtitleKey?: string;
+    badge: RowField | null;
+    details: RowField[];
+    more: RowField[];
+    avatar: ReactNode;
+}
+export interface ListParts {
+    title: string;
+    titleKey?: string;
+    subtitle: Array<{
+        key: string;
+        text: string;
+    }>;
+    badge: RowField | null;
+    avatar: ReactNode;
+}
+export type AvatarOption<T> = DataTableView<T>['avatar'];
+export declare function renderCell<T>(col: DataTableColumn<T>, row: T, index: number, labels: CellTextLabels): ReactNode;
+export declare function RowAvatar({ text, size }: {
+    text: string;
+    size?: 'sm' | 'md' | 'lg';
+}): React.JSX.Element;
+export declare function rowParts<T>(row: T, index: number, fields: DataTableCardFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>, labels: CellTextLabels): RowParts;
+export declare function listParts<T>(row: T, index: number, fields: DataTableListFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>, labels: CellTextLabels): ListParts;
+export declare function sampleRowParts<T>(fields: DataTableCardFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>): RowParts;
+export declare function sampleListParts<T>(fields: DataTableListFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>): ListParts;

package/dist/types/components/DataTable/data/useServerData.d.ts

@@ -0,0 +1,28 @@
+import type { DataTableDataSource, DataTableQuery } from '../types';
+export interface ServerDataState<TData> {
+    rows: TData[];
+    total: number;
+    rowsKey: string;
+    loading: boolean;
+    fetching: boolean;
+    error: unknown;
+    refetch: () => void;
+    tick: number;
+}
+export declare function filterPartOf(q: DataTableQuery): {
+    viewId: string;
+    viewParams: Record<string, unknown> | undefined;
+    search: string;
+    filterGroup: import("..").DataTableFilterGroup;
+    quickFilterIds: string[];
+};
+export declare function useServerData<TData>(dataSource: DataTableDataSource<TData> | undefined, query: DataTableQuery | null, opts?: {
+    rows?: boolean;
+}): ServerDataState<TData>;
+export interface ServerFiguresState<T> {
+    value: T | null;
+    loading: boolean;
+    error: unknown;
+    retry: () => void;
+}
+export declare function useServerFigures<T>(load: ((signal: AbortSignal) => Promise<T>) | undefined, key: string | null, tick: number): ServerFiguresState<T>;

package/dist/types/components/DataTable/defaults.d.ts

@@ -0,0 +1,18 @@
+import { type DataTableView, type DataTablePaginationConfig, type DataTableSortingConfig, type DataTableFilteringConfig, type DataTableSelectionConfig, type DataTableFilterGroup, type DataTableExportConfig, type DataTableExportFormat } from './types';
+export declare const DEFAULT_PAGE_SIZE = 25;
+export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
+export declare const DEFAULT_PAGINATION: DataTablePaginationConfig;
+export declare const DEFAULT_SORTING: DataTableSortingConfig;
+export declare const DEFAULT_FILTERING: DataTableFilteringConfig;
+export declare const DEFAULT_EXPORT_FORMATS: DataTableExportFormat[];
+export declare const DEFAULT_SELECTION: DataTableSelectionConfig;
+export declare function createEmptyFilterGroup(): DataTableFilterGroup;
+export declare function resolvePagination(config: DataTableView): DataTablePaginationConfig | false;
+export declare function resolveSorting(config: DataTableView): DataTableSortingConfig | false;
+export declare function resolveFiltering(config: DataTableView): DataTableFilteringConfig | false;
+export declare function resolveExport(config: DataTableView): DataTableExportConfig | false;
+export declare function resolveSelection(config: DataTableView): (DataTableSelectionConfig & {
+    show: 'onDemand' | 'always';
+}) | false;
+export declare function generateId(): string;
+export declare function getNestedValue(obj: any, path: string): any;

package/dist/types/components/DataTable/detail/BuiltInDetail.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { DataTableRowMenuConfig, DataTableColumn } from '../types';
+interface BuiltInDetailProps<T> {
+    row: T;
+    columns: DataTableColumn<T>[];
+    menu?: DataTableRowMenuConfig<T>;
+    close: () => void;
+}
+export declare function BuiltInDetail<T>({ row, columns, menu, close }: BuiltInDetailProps<T>): React.JSX.Element;
+export {};

package/dist/types/components/DataTable/detail/DetailHost.d.ts

@@ -0,0 +1,13 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableDetailContext } from '../types';
+interface DetailFrameProps {
+    ctx: DataTableDetailContext;
+    title: string;
+    bar?: boolean;
+    children: ReactNode;
+}
+export declare function DetailDrawer({ ctx, title, bar, children }: DetailFrameProps): React.ReactPortal | null;
+export declare function DetailFullScreen({ ctx, title, bar, children }: DetailFrameProps): React.ReactPortal | null;
+export declare function DetailPane({ ctx, title, bar, children }: DetailFrameProps): React.JSX.Element;
+export declare function DetailEmpty(): React.JSX.Element;
+export {};

package/dist/types/components/DataTable/export/ExportPopover.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type DataTableExportFormat, type DataTableExportAction, type DataTableExportResult } from '../types';
+interface ExportPopoverProps {
+    formats: DataTableExportFormat[];
+    onExport: (format: DataTableExportFormat, action: DataTableExportAction) => Promise<DataTableExportResult | undefined>;
+    totalRows: number;
+    selectedCount: number;
+    includeTotals: boolean;
+    includeSummary: boolean;
+    includeContext: boolean;
+    onToggleTotals: (val: boolean) => void;
+    onToggleSummary: (val: boolean) => void;
+    onToggleContext: (val: boolean) => void;
+    hasSummary: boolean;
+    onOpenSettings?: () => void;
+}
+declare const ExportPopover: React.FC<ExportPopoverProps>;
+export default ExportPopover;

package/dist/types/components/DataTable/export/ExportPreviewModal.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface ExportPreviewModalProps {
+    headers: string[];
+    rows: Record<string, any>[];
+    totalRowCount: number;
+    templateLabel: string;
+    onDownload: () => void;
+    onClose: () => void;
+}
+declare const ExportPreviewModal: React.FC<ExportPreviewModalProps>;
+export default ExportPreviewModal;

package/dist/types/components/DataTable/export/ExportSettingsModal.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { type DataTableColumn, type DataTableExportSettings, type DataTablePdfPageSize, type DataTablePdfOrientation, type DataTablePdfFontSize, type DataTablePdfMargins } from '../types';
+import { type SummaryChoiceCard } from '../summary/SummaryControls';
+export interface TemplateExportSettings {
+    customColumns: string[];
+    pdfPageSize: DataTablePdfPageSize;
+    pdfOrientation: DataTablePdfOrientation;
+    pdfFontSize: DataTablePdfFontSize;
+    pdfMargins: DataTablePdfMargins;
+}
+interface ExportSettingsModalProps {
+    settings: DataTableExportSettings;
+    columns: DataTableColumn[];
+    visibleColumns: string[];
+    columnOrder: string[];
+    summaryCards: SummaryChoiceCard[];
+    hasSummary: boolean;
+    onApply: (settings: DataTableExportSettings) => void;
+    onSave: (settings: DataTableExportSettings) => void;
+    onClose: () => void;
+    templateMode?: {
+        templateId: string;
+        templateLabel: string;
+        templateColumns: DataTableColumn[];
+        templateSettings?: TemplateExportSettings;
+        onApply: (templateId: string, settings: TemplateExportSettings) => void;
+        onSave: (templateId: string, settings: TemplateExportSettings) => void;
+    };
+}
+declare const ExportSettingsModal: React.FC<ExportSettingsModalProps>;
+export default ExportSettingsModal;

package/dist/types/components/DataTable/export/ExportTemplateCards.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { type DataTableExportTemplate, type DataTableExportFormat, type DataTableExportAction, type DataTableExportResult, type DataTableExportOptionValues } from '../types';
+interface ExportTemplateCardsProps {
+    visibleTemplates: DataTableExportTemplate[];
+    hiddenTemplates: DataTableExportTemplate[];
+    onExport: (templateId: string, format: DataTableExportFormat, action: DataTableExportAction) => Promise<DataTableExportResult | undefined>;
+    getRowCount: (templateId: string) => number;
+    getFormatAvailability: (templateId: string, format: DataTableExportFormat) => true | string;
+    templatePrefs?: Record<string, {
+        lastFormat?: DataTableExportFormat;
+    }>;
+    totalDataRows: number;
+    onOpenSettings?: (templateId: string) => void;
+    optionValues?: Record<string, DataTableExportOptionValues>;
+    onOptionChange?: (templateId: string, optionId: string, value: string | boolean) => void;
+    unavailableReasons?: Record<string, string>;
+}
+declare const ExportTemplateCards: React.FC<ExportTemplateCardsProps>;
+export default ExportTemplateCards;

package/dist/types/components/DataTable/export/exportContext.d.ts

@@ -0,0 +1,10 @@
+import { type DataTableLabels } from '../labels';
+import type { DataTableActiveFilter, DataTableExportMetadata } from '../types';
+export declare const labelsOf: (meta?: DataTableExportMetadata) => DataTableLabels;
+export declare const taxLabel: (meta: DataTableExportMetadata) => string;
+export declare function contextFilters(filters: DataTableActiveFilter[], names?: ReadonlyMap<string, string>): NonNullable<DataTableExportMetadata['filters']>;
+export interface ContextLineOptions {
+    rows?: 'export' | 'shown';
+}
+export declare function formatContextLine(meta: DataTableExportMetadata, opts?: ContextLineOptions): string;
+export declare function formatMetadataLines(meta: DataTableExportMetadata): Array<[string, string]>;

package/dist/types/components/DataTable/export/exportEngine.d.ts

@@ -0,0 +1,77 @@
+import { type DataTableExportFormat, type DataTableExportMetadata, type DataTableXlsxStyle, type DataTablePdfConfig, type DataTableColumn, type DataTableCellStyle, type DataTableExportSummary } from '../types';
+export { autoFormatValue, prepareExportRows, buildBusinessMeta } from './exportRows';
+export { formatContextLine, formatMetadataLines } from './exportContext';
+export type PdfFontFor = (text: string) => string | undefined;
+export interface ColumnMeta {
+    header: string;
+    align?: 'left' | 'center' | 'right';
+    type?: 'string' | 'number' | 'date' | 'boolean' | 'select' | 'array';
+    width?: number;
+    format?: 'text' | 'number' | 'currency' | 'date' | 'percentage';
+    cellStyle?: (value: any, row: any) => DataTableCellStyle | undefined;
+}
+export declare function buildColumnMeta(columns: DataTableColumn[], headers: string[]): ColumnMeta[];
+export declare function generateCSV(headers: string[], rows: Record<string, any>[], totals?: Record<string, any> | null, summary?: DataTableExportSummary | null, metadata?: DataTableExportMetadata, subtitle?: string): Blob;
+export declare function generateXLSX(headers: string[], rows: Record<string, any>[], config?: {
+    totals?: Record<string, any> | null;
+    summary?: DataTableExportSummary | null;
+    style?: DataTableXlsxStyle;
+    sheetName?: string;
+    columnMeta?: ColumnMeta[];
+    cellStyles?: Record<string, DataTableCellStyle>[];
+    metadata?: DataTableExportMetadata;
+    subtitle?: string;
+}): Promise<Blob>;
+export declare function generateJSON(rows: Record<string, any>[], summary?: DataTableExportSummary | null, metadata?: DataTableExportMetadata, subtitle?: string): Blob;
+export declare function generateHTML(headers: string[], rows: Record<string, any>[], config?: {
+    title?: string;
+    subtitle?: string;
+    totals?: Record<string, any> | null;
+    summary?: DataTableExportSummary | null;
+    customStyles?: string;
+    columnMeta?: ColumnMeta[];
+    cellStyles?: Record<string, DataTableCellStyle>[];
+    metadata?: DataTableExportMetadata;
+    branding?: {
+        name: string;
+        url?: string;
+    };
+}): Blob;
+export declare function generateTablePDFDocDef(headers: string[], rows: Record<string, any>[], config?: {
+    pdfConfig?: DataTablePdfConfig;
+    totals?: Record<string, any> | null;
+    summary?: DataTableExportSummary | null;
+    subtitle?: string;
+    columnMeta?: ColumnMeta[];
+    cellStyles?: Record<string, DataTableCellStyle>[];
+    metadata?: DataTableExportMetadata;
+    fontFor?: PdfFontFor;
+}): any;
+export { rawDataToBlob, downloadBlob, shareFile, openPreview, executeFileAction, getExtension, getFormatLabel, } from '../vendor';
+export declare function generateXML(headers: string[], rows: Record<string, any>[], config?: {
+    title?: string;
+    subtitle?: string;
+    totals?: Record<string, any> | null;
+    summary?: DataTableExportSummary | null;
+    metadata?: DataTableExportMetadata;
+}): Blob;
+export declare function buildExportBlob(format: DataTableExportFormat, headers: string[], rows: Record<string, any>[], config?: {
+    title?: string;
+    subtitle?: string;
+    totals?: Record<string, any> | null;
+    summary?: DataTableExportSummary | null;
+    xlsx?: DataTableXlsxStyle;
+    pdf?: DataTablePdfConfig;
+    html?: {
+        title?: string;
+        styles?: string;
+    };
+    totalKeys?: string[];
+    columns?: DataTableColumn[];
+    cellStyles?: Record<string, DataTableCellStyle>[];
+    metadata?: DataTableExportMetadata;
+    branding?: {
+        name: string;
+        url?: string;
+    };
+}): Promise<Blob>;

package/dist/types/components/DataTable/export/exportRows.d.ts

@@ -0,0 +1,10 @@
+import { type DataTableColumn, type DataTableCellStyle, type DataTableExportMetadata, type DataTableExportOptions } from '../types';
+import { type DataTableLabels } from '../labels';
+export declare function autoFormatValue(value: any, labels?: DataTableLabels): string | number;
+export declare function prepareExportRows<TData>(data: TData[], columns: DataTableColumn<TData>[], visibleKeys: string[], labels?: DataTableLabels): {
+    headers: string[];
+    rows: Record<string, any>[];
+    exportColumns: DataTableColumn<TData>[];
+    cellStyles?: Record<string, DataTableCellStyle>[];
+};
+export declare function buildBusinessMeta(host?: DataTableExportOptions): Pick<DataTableExportMetadata, 'businessName' | 'businessAddress' | 'businessPhone' | 'taxNumber' | 'taxNumberLabel'>;

package/dist/types/components/DataTable/export/templateDisplay.d.ts

@@ -0,0 +1,7 @@
+import { type DataTableExportTemplate, type DataTableExportTemplatePrefs } from '../types';
+export declare function isTemplateShown(template: DataTableExportTemplate, prefs: DataTableExportTemplatePrefs | undefined): boolean;
+export declare function orderTemplates<T extends DataTableExportTemplate>(templates: T[], prefs: DataTableExportTemplatePrefs | undefined): T[];
+export declare function splitTemplates(templates: DataTableExportTemplate[], prefs: DataTableExportTemplatePrefs | undefined, upfront: number): {
+    visible: DataTableExportTemplate[];
+    hidden: DataTableExportTemplate[];
+};

package/dist/types/components/DataTable/export/templateOptions.d.ts

@@ -0,0 +1,6 @@
+import type { DataTableColumn, DataTableExportOption, DataTableExportOptionContext, DataTableExportOptionValues, DataTableExportTemplate } from '../types';
+export declare const optionsOf: (template: Pick<DataTableExportTemplate, "options">) => DataTableExportOption[];
+export declare const resolveOptionValues: (template: Pick<DataTableExportTemplate, "options">, stored?: DataTableExportOptionValues) => DataTableExportOptionValues;
+export declare const optionContext: (values: DataTableExportOptionValues) => DataTableExportOptionContext;
+export declare const resolveTemplateColumns: (template: Pick<DataTableExportTemplate, "columns">, ctx: DataTableExportOptionContext) => DataTableColumn[];
+export declare const resolveTemplateParams: (template: Pick<DataTableExportTemplate, "params">, ctx: DataTableExportOptionContext) => Record<string, unknown> | undefined;

package/dist/types/components/DataTable/export/useTableExport.d.ts

@@ -0,0 +1,53 @@
+import { type DataTableColumn, type DataTableExportTemplate, type DataTableExportFormat, type DataTableExportAction, type DataTableExportSettings, type DataTableActiveFilter, type DataTableExportResult, type DataTableExportConfig, type DataTablePdfConfig, type DataTableExportSummary, type DataTableExportTemplatePrefs, type DataTableExportOptions, type DataTableAllRowsResult, type DataTableAuthorize, type DataTableSelection } from '../types';
+import type { DataTableExportOptionValues } from '../types';
+import { type DataTableLabels } from '../labels';
+interface UseTableExportOptions<TData> {
+    columns: DataTableColumn<TData>[];
+    exportConfig?: DataTableExportConfig<TData>;
+    selection: DataTableSelection<TData>;
+    rows: TData[];
+    visibleColumns: string[];
+    globalFilter: string;
+    activeFilters: DataTableActiveFilter[];
+    tableId?: string;
+    exportColumns?: string[];
+    totalDataRows: number;
+    matchingCount: number;
+    exportSettings: DataTableExportSettings;
+    context?: Record<string, any>;
+    templateColumnOverrides?: Record<string, {
+        customColumns?: string[];
+        options?: DataTableExportOptionValues;
+    }>;
+    templatePrefs?: DataTableExportTemplatePrefs;
+    exportOptions?: DataTableExportOptions;
+    authorize?: DataTableAuthorize;
+    loadAllRows?: (format: DataTableExportFormat, action: DataTableExportAction, params?: Record<string, unknown>) => Promise<DataTableAllRowsResult<TData>>;
+    labels?: DataTableLabels;
+    locale?: string;
+}
+interface UseTableExportReturn {
+    hasExport: boolean;
+    hasQuickExport: boolean;
+    quickFormats: DataTableExportFormat[];
+    visibleTemplates: DataTableExportTemplate[];
+    hiddenTemplates: DataTableExportTemplate[];
+    unavailableReasons: Record<string, string>;
+    executeQuickExport: (format: DataTableExportFormat, action: DataTableExportAction, options?: ExportOptions) => Promise<DataTableExportResult | undefined>;
+    executeTemplateExport: (templateId: string, format: DataTableExportFormat, action: DataTableExportAction, options?: ExportOptions) => Promise<DataTableExportResult | undefined>;
+    getTemplateRowCount: (templateId: string) => number;
+    getPreviewData: (templateId?: string) => Promise<{
+        headers: string[];
+        rows: Record<string, any>[];
+        totalCount: number;
+    } | null>;
+    getFormatAvailability: (templateId: string, format: DataTableExportFormat) => true | string;
+}
+interface ExportOptions {
+    includeTotals?: boolean;
+    includeSummary?: boolean;
+    computedSummary?: DataTableExportSummary;
+    pdfConfig?: DataTablePdfConfig;
+}
+export declare function useTableExport<TData>(options: UseTableExportOptions<TData>): UseTableExportReturn;
+export {};

package/dist/types/components/DataTable/filters/ColumnFilterPopover.d.ts

@@ -0,0 +1,14 @@
+import React, { type RefObject } from 'react';
+import type { DataTableFilterGroup, DataTableColumn } from '../types';
+import { type ColumnFilterKind } from './columnFilterModel';
+interface ColumnFilterPopoverProps {
+    anchorRef: RefObject<HTMLElement | null>;
+    column: DataTableColumn;
+    kind: ColumnFilterKind;
+    filterGroup: DataTableFilterGroup;
+    setFilterGroup: (group: DataTableFilterGroup) => void;
+    operators?: readonly string[];
+    onClose: () => void;
+}
+export declare function ColumnFilterPopover({ anchorRef, column, kind, filterGroup, setFilterGroup, operators, onClose }: ColumnFilterPopoverProps): React.JSX.Element;
+export default ColumnFilterPopover;

package/dist/types/components/DataTable/filters/FilterChips.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type DataTableActiveFilter } from '../types';
+interface FilterChipsProps {
+    filters: DataTableActiveFilter[];
+    onRemove: (id: string) => void;
+    onClearAll: () => void;
+}
+declare const FilterChips: React.FC<FilterChipsProps>;
+export default FilterChips;

package/dist/types/components/DataTable/filters/FilterConditionRow.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type DataTableFilterCondition, type DataTableColumn } from '../types';
+interface FilterConditionRowProps {
+    condition: DataTableFilterCondition;
+    columns: DataTableColumn[];
+    onChange: (updated: DataTableFilterCondition) => void;
+    onRemove: () => void;
+    table?: any;
+}
+declare const FilterConditionRow: React.FC<FilterConditionRowProps>;
+export default FilterConditionRow;

package/dist/types/components/DataTable/filters/FilterGroup.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type DataTableFilterGroup as FilterGroupType, type DataTableColumn } from '../types';
+interface FilterGroupProps {
+    group: FilterGroupType;
+    columns: DataTableColumn[];
+    onChange: (updated: FilterGroupType) => void;
+    onRemove?: () => void;
+    isRoot?: boolean;
+    table?: any;
+}
+declare const FilterGroupEditor: React.FC<FilterGroupProps>;
+export default FilterGroupEditor;

package/dist/types/components/DataTable/filters/FilterModal.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type DataTableFilterGroup as FilterGroupType, type DataTableColumn, type DataTableSavedFilter } from '../types';
+interface FilterModalProps {
+    filterGroup: FilterGroupType;
+    setFilterGroup: (group: FilterGroupType) => void;
+    columns: DataTableColumn[];
+    onClose: () => void;
+    table?: any;
+    savedFilters?: DataTableSavedFilter[];
+    onSaveFilter?: (preset: DataTableSavedFilter) => void;
+    onDeleteFilter?: (id: string) => void;
+}
+declare const FilterModal: React.FC<FilterModalProps>;
+export default FilterModal;

package/dist/types/components/DataTable/filters/FilterRow.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { DataTableFilterGroup, DataTableColumn } from '../types';
+export interface FilterRowCellPlacement {
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface FilterRowProps {
+    columnKeys: string[];
+    columns: DataTableColumn[];
+    filterGroup: DataTableFilterGroup;
+    setFilterGroup: (group: DataTableFilterGroup) => void;
+    debounceMs: number;
+    hasSelection: boolean;
+    hasActionColumn: boolean;
+    placement: (columnKey: string) => FilterRowCellPlacement;
+    selectionCellClassName?: string;
+    actionCellClassName?: string;
+}
+declare const FilterRow: React.FC<FilterRowProps>;
+export default FilterRow;

package/dist/types/components/DataTable/filters/columnFilterModel.d.ts

@@ -0,0 +1,29 @@
+import { type DataTableFilterCondition, type DataTableFilterGroup, type DataTableColumn } from '../types';
+export type ColumnFilterKind = 'options' | 'text' | 'number' | 'date' | 'boolean';
+export type ColumnFilterState = {
+    kind: 'options';
+    mode: 'any' | 'none';
+    values: string[];
+} | {
+    kind: 'text';
+    op: 'contains' | 'equals';
+    text: string;
+} | {
+    kind: 'number';
+    min: string;
+    max: string;
+} | {
+    kind: 'date';
+    from: string;
+    to: string;
+} | {
+    kind: 'boolean';
+    value: '' | 'true' | 'false';
+};
+export declare function columnFilterKind(col: DataTableColumn, operators?: readonly string[]): ColumnFilterKind | null;
+export declare function columnFilterNoneOffered(col: DataTableColumn, operators?: readonly string[]): boolean;
+export declare function columnFilterEqualsOffered(operators?: readonly string[]): boolean;
+export declare function emptyColumnFilter(kind: ColumnFilterKind): ColumnFilterState;
+export declare function readColumnFilter(group: DataTableFilterGroup, col: DataTableColumn, kind: ColumnFilterKind): ColumnFilterState;
+export declare function columnFilterCondition(col: DataTableColumn, state: ColumnFilterState): DataTableFilterCondition | null;
+export declare function writeColumnFilter(group: DataTableFilterGroup, col: DataTableColumn, kind: ColumnFilterKind, state: ColumnFilterState | null): DataTableFilterGroup;

package/dist/types/components/DataTable/filters/filterEngine.d.ts

@@ -0,0 +1,16 @@
+import { type DataTableFilterCondition, type DataTableFilterGroup, type DataTableActiveFilter, type DataTableColumn, type DataTableColumnType } from '../types';
+import { type DataTableLabels } from '../labels';
+export declare function columnOperators(type: string): readonly string[];
+export declare const OPTION_OPERATORS: readonly string[];
+export declare function operatorLabel(operator: string, labels?: DataTableLabels): string;
+export declare function getOperatorsForType(type: string, labels?: DataTableLabels): Array<{
+    value: string;
+    label: string;
+}>;
+export declare function inferColumnType(value: any): DataTableColumnType;
+export declare function dayKey(v: unknown): string | null;
+export declare function evaluateCondition(row: any, condition: DataTableFilterCondition, columns?: DataTableColumn[]): boolean;
+export declare function evaluateGroup(row: any, group: DataTableFilterGroup, columns?: DataTableColumn[]): boolean;
+export declare function flattenActiveFilters(group: DataTableFilterGroup, columns: DataTableColumn[], labels?: DataTableLabels): DataTableActiveFilter[];
+export declare function removeConditionById(group: DataTableFilterGroup, id: string): DataTableFilterGroup;
+export declare function hasActiveConditions(group: DataTableFilterGroup): boolean;

package/dist/types/components/DataTable/filters/filterRowModel.d.ts

@@ -0,0 +1,28 @@
+import { type DataTableFilterCondition, type DataTableFilterGroup, type DataTableColumn } from '../types';
+export declare const FILTER_ROW_ID_PREFIX = "filter-row:";
+export type FilterRowKind = 'text' | 'number' | 'date' | 'select' | 'boolean';
+export type FilterRowValue = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'number';
+    min: string;
+    max: string;
+} | {
+    kind: 'date';
+    from: string;
+    to: string;
+} | {
+    kind: 'select';
+    value: string;
+} | {
+    kind: 'boolean';
+    value: '' | 'true' | 'false';
+};
+export declare function filterRowKind(col: DataTableColumn, operators?: readonly string[]): FilterRowKind | null;
+export declare const emptyFilterRowValue: (kind: FilterRowKind) => FilterRowValue;
+export declare function filterRowCondition(col: DataTableColumn, value: FilterRowValue): DataTableFilterCondition | null;
+export declare function filterRowValueOf(kind: FilterRowKind, cond: DataTableFilterCondition | undefined): FilterRowValue;
+export declare function readFilterRowCondition(group: DataTableFilterGroup, columnKey: string): DataTableFilterCondition | undefined;
+export declare function writeFilterRowCondition(group: DataTableFilterGroup, columnKey: string, cond: DataTableFilterCondition | null): DataTableFilterGroup;
+export declare function clearFilterRowConditions(group: DataTableFilterGroup): DataTableFilterGroup;

package/dist/types/components/DataTable/filters/quickFilterMatch.d.ts

@@ -0,0 +1,3 @@
+import { type DataTableFilterCondition, type DataTableFilterGroup, type DataTableQuickFilter, type DataTableSavedFilter } from '../types';
+export declare function conditionsStillApplied(group: DataTableFilterGroup, conditions: DataTableFilterCondition[]): boolean;
+export declare function quickFiltersStillOn(ids: string[], group: DataTableFilterGroup, quickFilters: DataTableQuickFilter[] | undefined, savedFilters: DataTableSavedFilter[]): string[];

package/dist/types/components/DataTable/grouping/GroupUi.d.ts

@@ -0,0 +1,36 @@
+import React, { type ReactNode } from 'react';
+import type { DataTableColumn } from '../types';
+import type { DisplayItem, GroupNode } from './groupModel';
+interface GroupLineProps {
+    item: DisplayItem;
+    place: 'table' | 'card' | 'split';
+    keyboard: boolean;
+    tabbable: boolean;
+    columnHeader?: string;
+    onToggle: (key: string) => void;
+    selection?: {
+        checked: boolean;
+        indeterminate: boolean;
+        onToggle: () => void;
+    } | null;
+    summary?: ReactNode;
+    onShowAll: (node: GroupNode) => void;
+    onRetry: (node: GroupNode) => void;
+}
+export declare function GroupLine({ item, place, keyboard, tabbable, columnHeader, onToggle, selection, summary, onShowAll, onRetry }: GroupLineProps): React.JSX.Element | null;
+export declare function GroupButton({ columns, levels, maxDepth, onChange }: {
+    columns: DataTableColumn[];
+    levels: string[];
+    maxDepth: number;
+    onChange: (levels: string[]) => void;
+}): React.JSX.Element | null;
+interface GroupChipsProps {
+    columns: DataTableColumn[];
+    levels: string[];
+    maxDepth: number;
+    onChange: (levels: string[]) => void;
+    onExpandAll: () => void;
+    onCollapseAll: () => void;
+}
+export declare function GroupChips({ columns, levels, maxDepth, onChange, onExpandAll, onCollapseAll }: GroupChipsProps): React.JSX.Element | null;
+export {};