@snksergio/design-system 0.5.0 → 0.17.0

package/dist-lib/src/components/ui/DataTable/parts/data-table-row-expansion.d.ts

@@ -0,0 +1,28 @@
+import { ReactNode } from 'react';
+export type DataTableRowExpansionProps<T> = {
+    row: T;
+    render: (params: {
+        row: T;
+    }) => ReactNode;
+    /** Style inline pra virtualização. */
+    style?: React.CSSProperties;
+};
+/**
+ * Slot expandido abaixo de uma row — full-width, sticky-left no eixo horizontal.
+ *
+ * Não respeita estrutura de colunas da tabela. Consumer pode renderizar:
+ *  - Sub-tabela com colunas próprias
+ *  - Lista compacta de campos (key/value)
+ *  - Cards de detalhe
+ *  - Gráficos, timeline, qualquer coisa
+ *
+ * `sticky left-0` garante que o conteúdo fica visível mesmo quando há scroll
+ * horizontal na tabela principal (cells da row vão pra direita, mas o
+ * expansion permanece ancorado no viewport).
+ *
+ * Trade-off com virtualize: `estimateRowHeight` é fixo. Se conteúdo expandido
+ * tem altura variável grande, virtualização pode sub/super estimar — passe
+ * `estimateRowHeight` adequado ou desligue virtualize.
+ */
+export declare function DataTableRowExpansion<T>({ row, render, style, }: DataTableRowExpansionProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=data-table-row-expansion.d.ts.map

package/dist-lib/src/components/ui/DataTable/parts/data-table-row-expansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-row-expansion.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/parts/data-table-row-expansion.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,GAAG,EAAE,CAAC,CAAC;IACP,MAAM,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,CAAC,CAAA;KAAE,KAAK,SAAS,CAAC;IAC1C,sCAAsC;IACtC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,EACvC,GAAG,EACH,MAAM,EACN,KAAK,GACN,EAAE,0BAA0B,CAAC,CAAC,CAAC,2CAiB/B"}

package/dist-lib/src/components/ui/DataTable/parts/data-table-row.d.ts

@@ -0,0 +1,76 @@
+import { MutableRefObject } from 'react';
+import { DataTableColumnDef, GridRowId } from '../data-table.types';
+import { DataTableTreeMeta } from './data-table-tree-toggle';
+/**
+ * Estado de edição inline da row (só não-null pra row com célula em edição).
+ * Bundled num objeto pra que `isLoading`/`error` não vazem pras outras rows:
+ * só a row em edição recebe um objeto novo → só ela re-renderiza.
+ */
+export type DataTableRowEditState = {
+    field: string;
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Handlers da row — passados via REF estável (atualizado a cada render do pai).
+ * Evita re-render por mudança de identidade de handler (o ref nunca muda) e
+ * evita stale closures (lê sempre o `.current` mais recente no event time).
+ */
+export type DataTableRowHandlers<T> = {
+    getRowId: (row: T) => GridRowId;
+    onRowClick: (row: T, index: number) => void;
+    onRowKeyDown: (e: React.KeyboardEvent<HTMLDivElement>, index: number, row: T) => void;
+    onRowFocus: (index: number) => void;
+    toggleRowSelection: (row: T) => void;
+    toggleRowExpansion: (rowId: GridRowId) => void;
+    /** Toggle expand/collapse de um nó da árvore (modo tree-data). */
+    toggleTreeNode: (rowId: GridRowId) => void;
+    startEditingCell: (rowId: GridRowId, field: string) => void;
+    onCellEditCommit: (params: {
+        row: T;
+        field: string;
+        value: unknown;
+        oldValue: unknown;
+    }) => void;
+    onCellEditCancel: () => void;
+    registerRef: (index: number, el: HTMLDivElement | null) => void;
+};
+export type DataTableRowProps<T> = {
+    row: T;
+    index: number;
+    rowId: GridRowId;
+    selected: boolean;
+    focused: boolean;
+    expanded: boolean;
+    /** null quando a row não está em edição; objeto novo só pra row editando. */
+    editState: DataTableRowEditState | null;
+    /** Classe da row — computada no pai (getRowClassName) pra o memo comparar. */
+    rowClassName?: string;
+    virtualStyle?: React.CSSProperties;
+    columns: DataTableColumnDef<T>[];
+    columnWidths: Record<string, number>;
+    stickyOffsets: Record<string, number>;
+    selectionEnabled: boolean;
+    clickable: boolean;
+    useRowExpansion: boolean;
+    expandableColField: string | null;
+    /** Field da coluna primária da árvore — recebe indentação + chevron. null = sem tree. */
+    treeColField: string | null;
+    /** Metadados de hierarquia da row (level/hasChildren/...). null fora do modo tree. */
+    treeMeta: DataTableTreeMeta | null;
+    /** Mostra contagem de descendentes "(N)" no nó. */
+    treeShowDescendantCount: boolean;
+    handlers: MutableRefObject<DataTableRowHandlers<T>>;
+};
+declare function DataTableRowInner<T>({ row, index, rowId, selected, focused, expanded, editState, rowClassName, virtualStyle, columns, columnWidths, stickyOffsets, selectionEnabled, clickable, useRowExpansion, expandableColField, treeColField, treeMeta, treeShowDescendantCount, handlers, }: DataTableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+/**
+ * `DataTableRow` — row memoizada. Barreira de re-render: só re-renderiza quando
+ * suas props reativas mudam (selected/focused/expanded/editState) ou os dados de
+ * render (columns/widths). Mudanças globais de estado do DataTable (foco em outra
+ * row, abrir popover, refresh) NÃO repintam rows não-afetadas.
+ *
+ * Generics preservados via cast (React.memo perde o param de tipo).
+ */
+export declare const DataTableRow: typeof DataTableRowInner;
+export {};
+//# sourceMappingURL=data-table-row.d.ts.map

package/dist-lib/src/components/ui/DataTable/parts/data-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-row.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/parts/data-table-row.tsx"],"names":[],"mappings":"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"}

package/dist-lib/src/components/ui/DataTable/parts/data-table-totalizer-row.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+import { DataTableColumnDef } from '../data-table.types';
+export type DataTableTotalizerRowProps<T> = {
+    /** Colunas efetivas (apos hidden/order) — mesma fonte do header. */
+    columns: DataTableColumnDef<T>[];
+    /** Rows pra agregar. Em client mode: allPagesProcessed (todas filtradas).
+     *  Em server mode: current page rows (ou empty se consumer só usar aggregateRow). */
+    rows: T[];
+    /** Override pre-computado por field — vence aggregate built-in/custom. */
+    overrides?: Record<string, ReactNode>;
+    /** Widths efetivos por field (mesma fonte do header pra alinhar). */
+    columnWidths: Record<string, number>;
+    /** Sticky offsets pra colunas pinned. */
+    stickyOffsets: Record<string, number>;
+    /** Tem coluna de selection enabled? Renderiza cell vazia na esquerda. */
+    hasSelection?: boolean;
+};
+/**
+ * Footer row sticky no bottom do body — mostra agregacoes por coluna.
+ *
+ * Para cada coluna:
+ *   - Se `overrides[field]` definido → renderiza esse valor (server mode).
+ *   - Senao, se `column.aggregate` definido → computa local.
+ *   - Senao, cell vazia (apenas mantem largura/alinhamento).
+ *
+ * `column.aggregate` aceita:
+ *   - 'sum' | 'avg' | 'count' | 'min' | 'max' — built-ins (so funcionam em valores numericos).
+ *   - (rows: T[]) => ReactNode — funcao custom, recebe rows pra computar livremente.
+ *
+ * Formatacao do resultado built-in: `column.aggregateFormatter(value)` >
+ * `column.valueFormatter(value)` > toString.
+ */
+export declare function DataTableTotalizerRow<T>({ columns, rows, overrides, columnWidths, stickyOffsets, hasSelection, }: DataTableTotalizerRowProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=data-table-totalizer-row.d.ts.map

package/dist-lib/src/components/ui/DataTable/parts/data-table-totalizer-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-totalizer-row.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/parts/data-table-totalizer-row.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,oEAAoE;IACpE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;IACjC;yFACqF;IACrF,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,yCAAyC;IACzC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,yEAAyE;IACzE,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,EACvC,OAAO,EACP,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,aAAa,EACb,YAAoB,GACrB,EAAE,0BAA0B,CAAC,CAAC,CAAC,2CAoC/B"}

package/dist-lib/src/components/ui/DataTable/parts/data-table-tree-toggle.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+/**
+ * Metadados de hierarquia da row, propagados do `buildTreeRows` até a cell da
+ * coluna primária. Bundle estável (objeto novo só quando muda) pra não invalidar
+ * o memo da row sem necessidade.
+ */
+export type DataTableTreeMeta = {
+    level: number;
+    hasChildren: boolean;
+    isExpanded: boolean;
+    descendantCount: number;
+    childCount: number;
+};
+export type DataTableTreeToggleProps = {
+    meta: DataTableTreeMeta;
+    /** Conteúdo original da cell (label da coluna primária). */
+    children: ReactNode;
+    /** Mostra "(N)" descendentes ao lado do label. */
+    showDescendantCount?: boolean;
+    /** Toggle expand/collapse do nó. */
+    onToggle: () => void;
+};
+/**
+ * Prefixo de tree-data na coluna primária: indentação por nível + chevron
+ * (quando o nó tem filhos) + label + contagem opcional de descendentes.
+ *
+ * Indentação: `calc(var(--spacing-pad-2xl) * level)` — usa o token DS
+ * `pad-2xl` (16px) como unidade por nível, multiplicado inline. Sem hardcode de
+ * px (a unidade é o CSS var do token; o multiplicador é o nível, um número).
+ *
+ * Nós-folha (sem filhos) reservam o mesmo espaço do chevron (`size-icon-sm`)
+ * pra que os labels alinhem verticalmente independente de ter ou não chevron.
+ */
+export declare function DataTableTreeToggle({ meta, children, showDescendantCount, onToggle, }: DataTableTreeToggleProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=data-table-tree-toggle.d.ts.map

package/dist-lib/src/components/ui/DataTable/parts/data-table-tree-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-tree-toggle.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/parts/data-table-tree-toggle.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,iBAAiB,CAAC;IACxB,4DAA4D;IAC5D,QAAQ,EAAE,SAAS,CAAC;IACpB,kDAAkD;IAClD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oCAAoC;IACpC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,QAAQ,EACR,mBAA2B,EAC3B,QAAQ,GACT,EAAE,wBAAwB,2CAgD1B"}

package/dist-lib/src/components/ui/DataTable/parts/sortable-head-cell.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { TableHeadCellProps } from '../../Table';
+export type DataTableSortableHeadCellProps = TableHeadCellProps & {
+    /** ID unico do item no SortableContext (== field). Obrigatorio pra dnd. */
+    sortableId: string;
+    /** Quando true, desabilita drag (usado pra coluna actions). */
+    disableDrag?: boolean;
+    children?: ReactNode;
+};
+/**
+ * Wrapper do TableHeadCell que adiciona drag-and-drop via @dnd-kit/sortable.
+ *
+ * - Activation constraint de 5px no PointerSensor (DndContext) preserva click-to-sort.
+ * - Aplica `transform` + `transition` durante drag (CSS smooth movement).
+ * - Reduz opacidade do item em drag pra dar feedback visual.
+ * - Spread `attributes` + `listeners` via `rootProps` — listeners ficam na cell
+ *   inteira (drag activator) mas mousedown/click do resize handle + column menu
+ *   button já tem stopPropagation, então não conflitam.
+ *
+ * Quando `disableDrag=true`, o item participa do SortableContext (mantem layout)
+ * mas não pode ser arrastado nem ser drop target.
+ */
+export declare function DataTableSortableHeadCell({ sortableId, disableDrag, children, ...headCellProps }: DataTableSortableHeadCellProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=sortable-head-cell.d.ts.map

package/dist-lib/src/components/ui/DataTable/parts/sortable-head-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortable-head-cell.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/parts/sortable-head-cell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,MAAM,8BAA8B,GAAG,kBAAkB,GAAG;IAChE,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,UAAU,EACV,WAAmB,EACnB,QAAQ,EACR,GAAG,aAAa,EACjB,EAAE,8BAA8B,2CAiDhC"}

package/dist-lib/src/components/ui/DataTable/services/saved-views-mock-service.d.ts

@@ -0,0 +1,7 @@
+import { SavedViewsService } from './saved-views.types';
+/**
+ * Service mock — persiste em localStorage via key separada de state-persistence.
+ * Para producao: substituir por adapter que chama API. Mesma interface, comportamento assincrono.
+ */
+export declare const savedViewsMockService: SavedViewsService;
+//# sourceMappingURL=saved-views-mock-service.d.ts.map

package/dist-lib/src/components/ui/DataTable/services/saved-views-mock-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saved-views-mock-service.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/services/saved-views-mock-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AA6BxE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,iBAmBnC,CAAC"}

package/dist-lib/src/components/ui/DataTable/services/saved-views.types.d.ts

@@ -0,0 +1,69 @@
+import { DataTableViewMode, FilterModel, GridRowId, SortModel } from '../data-table.types';
+import { ColumnPinned, TableDensity } from '../../Table';
+/**
+ * Snapshot do estado capturado por uma view (saved OR preset).
+ *
+ * **Capturado** (persistente):
+ * - filterModel, sortModel — base filtros/ordenação
+ * - density — visual da tabela
+ * - columnWidths/pinnedColumns/hiddenColumns/columnOrder — layout das colunas
+ * - viewMode — tabela OU kanban (quando integração viewMode ativa)
+ * - groupBy — agrupamento por field (quando feature ativa)
+ * - expandedRowIds — rows expandidas (quando feature ativa)
+ *
+ * **Não capturado** (volátil/sessão):
+ * - search — limpa entre views
+ * - paginationModel — page reseta ao aplicar filtros
+ * - selectionModel — sessão; não tem sentido persistir
+ * - virtualize/totalizers/etc — config-time, não state
+ *
+ * Layout fields (columnWidths/pinnedColumns/hiddenColumns/columnOrder) e features
+ * novas (viewMode/groupBy/expandedRowIds) são **opcionais** pra permitir presets
+ * declarativos minimalistas. Quando ausente, `applyView` aplica defaults
+ * razoáveis (layout default, viewMode "table", sem groupBy, sem expansion).
+ */
+export type DataTableSavedViewState = {
+    filterModel: FilterModel;
+    /** Multi-sort — array de criterios (primeiro = prioridade maior). */
+    sortModel: SortModel[];
+    density: TableDensity;
+    columnWidths?: Record<string, number>;
+    pinnedColumns?: Record<string, ColumnPinned>;
+    hiddenColumns?: string[];
+    columnOrder?: string[];
+    /** Modo de visualização — "table" (default histórico) ou "kanban". */
+    viewMode?: DataTableViewMode;
+    /** Field pelo qual agrupar (Fase F.4). `undefined` = sem grouping. */
+    groupBy?: string;
+    /** IDs de rows expandidas (Fase F.4b). `undefined`/`[]` = todas colapsadas. */
+    expandedRowIds?: GridRowId[];
+};
+/**
+ * Conjunto de configurações nomeado que o usuário pode salvar e re-aplicar.
+ * Inclui filtros, sort, layout, density, e features capturadas em `state`.
+ */
+export type SavedView = {
+    id: string;
+    name: string;
+    /**
+     * `true` = visivel pra todos os usuarios da equipe (mostrada na tab "Todos").
+     * `false` = privada, so o autor ve (tab "Pessoais"). Default `false`.
+     * Mock service nao tem multi-user real — o flag eh persistido pra quando
+     * backend real entrar.
+     */
+    isPublic: boolean;
+    /** Snapshot do estado capturado no momento do save. */
+    state: DataTableSavedViewState;
+    /** ISO date — usado pra ordenacao na lista. */
+    createdAt: string;
+};
+/**
+ * Service trocavel — mock usa localStorage. Em producao, substituir por adapter
+ * que persiste em backend via API. Mesma interface, comportamento async.
+ */
+export type SavedViewsService = {
+    list: (persistId: string) => Promise<SavedView[]>;
+    save: (persistId: string, view: SavedView) => Promise<SavedView>;
+    delete: (persistId: string, id: string) => Promise<void>;
+};
+//# sourceMappingURL=saved-views.types.d.ts.map

package/dist-lib/src/components/ui/DataTable/services/saved-views.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saved-views.types.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/services/saved-views.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,SAAS,EACT,SAAS,EACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,WAAW,CAAC;IACzB,qEAAqE;IACrE,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,OAAO,EAAE,YAAY,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC7C,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,cAAc,CAAC,EAAE,SAAS,EAAE,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,KAAK,EAAE,uBAAuB,CAAC;IAC/B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAClD,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACjE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D,CAAC"}

package/dist-lib/src/components/ui/DataTable/utils/aggregate.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { DataTableColumnDef } from '../data-table.types';
+/**
+ * Agregação de coluna — fonte ÚNICA. Antes a mesma lógica (switch
+ * sum/avg/count/min/max + filtro de números + formatter) estava duplicada em
+ * `data-table-group-header-row` e `data-table-totalizer-row`, com uma
+ * divergência sutil: o totalizer NÃO respeitava `col.valueGetter` (lia só o
+ * dot-path), o group-header sim. Agora ambos usam `applyValueGetter` → consistente.
+ */
+/**
+ * Computa o valor agregado built-in (sum/avg/count/min/max) de uma coluna sobre
+ * `rows`. Retorna `null` quando `aggregate` não é um keyword built-in numérico.
+ */
+export declare function computeAggregate<T>(col: DataTableColumnDef<T>, rows: T[]): number | null;
+/**
+ * Resolve o conteúdo renderizável do aggregate de uma coluna:
+ *  1. `override` explícito (quando passado, ex: aggregateRow do server mode)
+ *  2. `col.aggregate` função custom → ReactNode livre
+ *  3. keyword built-in → número computado + `aggregateFormatter ?? valueFormatter`
+ *  4. senão → null
+ */
+export declare function renderAggregate<T>(col: DataTableColumnDef<T>, rows: T[], override?: ReactNode): ReactNode;
+//# sourceMappingURL=aggregate.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D;;;;;;GAMG;AAEH;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,EAAE,GACR,MAAM,GAAG,IAAI,CAsBf;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,EAAE,EACT,QAAQ,CAAC,EAAE,SAAS,GACnB,SAAS,CASX"}

package/dist-lib/src/components/ui/DataTable/utils/calculate-column-widths.d.ts

@@ -0,0 +1,28 @@
+import { DataTableColumnDef } from '../data-table.types';
+/** Largura default quando nem `col.width` nem `typeDef.defaultWidth` definem. */
+export declare const DEFAULT_COLUMN_WIDTH = 160;
+/** Padding horizontal somado ao texto medido — alinha com `px-pad-2xl` (16px×2). */
+export declare const CELL_PADDING_PX = 32;
+/** Tamanho default da amostra de rows pra Layer 2. */
+export declare const DEFAULT_SAMPLE_SIZE = 20;
+export interface CalculateColumnWidthsOptions {
+    /** Largura interna do container observada via ResizeObserver. */
+    containerWidth: number;
+    /** Habilita Layer 2 (canvas measure) globalmente. */
+    autoFit: boolean;
+    /** Tamanho da amostra de rows para Layer 2. Default 20. */
+    sampleSize?: number;
+}
+/**
+ * Calcula widths das colunas em 3 camadas.
+ *
+ * Retorna `Record<field, number>` com widths em pixels. Apenas colunas que
+ * NÃO têm `col.width` explícito do consumer recebem widths calculados.
+ * Colunas com `col.width` ficam de fora do retorno — `useDataTableColumns`
+ * usa `col.width` como fallback quando o autoWidth não tem entry.
+ *
+ * Quando `containerWidth <= 0` (mount inicial antes do ResizeObserver),
+ * retorna {} — `useDataTableColumns` cai no fallback de `col.width`/typeDef.
+ */
+export declare function calculateColumnWidths<T>(columns: DataTableColumnDef<T>[], rows: T[], options: CalculateColumnWidthsOptions): Record<string, number>;
+//# sourceMappingURL=calculate-column-widths.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/calculate-column-widths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-column-widths.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/calculate-column-widths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAM9D,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,oFAAoF;AACpF,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,MAAM,WAAW,4BAA4B;IAC3C,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,EAChC,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,EAAE,4BAA4B,GACpC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwGxB"}

package/dist-lib/src/components/ui/DataTable/utils/expand-rows.d.ts

@@ -0,0 +1,27 @@
+import { GridRowId } from '../data-table.types';
+/** Marker pra "row expansion" — substitui ou se intercala com data rows.
+ *  Symbol-as-discriminator pra evitar conflito com props do T. */
+export declare const ROW_EXPANSION_TYPE: unique symbol;
+export type DataTableRowExpansionItem<T = unknown> = {
+    __type: typeof ROW_EXPANSION_TYPE;
+    /** ID da row que está expandida (== getRowId(row)). */
+    id: GridRowId;
+    /** Referência à row pai pra que o render do consumer tenha acesso. */
+    row: T;
+};
+/** Type guard pra ExpansionRow. Aceita union ampla (T | GroupRow | GroupContent | etc)
+ *  pra coexistir com outras transformações no mesmo array. */
+export declare function isExpansionRow<T>(item: unknown): item is DataTableRowExpansionItem<T>;
+/**
+ * Reshape do array de rows pra incluir markers de expansão.
+ * Após cada row que tem ID em `expandedIds`, insere 1 marker de expansão.
+ *
+ * Resultado é um array misto `(T | DataTableRowExpansionItem<T>)[]` — o render
+ * faz branching via `isExpansionRow` type guard. Virtualizer recebe esse array
+ * direto e calcula scroll height baseado em count.
+ *
+ * Quando `expandedIds` vazia ou nenhum row match, retorna o array original
+ * (referência preservada pra evitar re-renders desnecessários).
+ */
+export declare function expandRows<T>(rows: T[], expandedIds: Set<GridRowId>, getRowId: (row: T) => GridRowId): Array<T | DataTableRowExpansionItem<T>>;
+//# sourceMappingURL=expand-rows.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/expand-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand-rows.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/expand-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD;kEACkE;AAClE,eAAO,MAAM,kBAAkB,eAA6B,CAAC;AAE7D,MAAM,MAAM,yBAAyB,CAAC,CAAC,GAAG,OAAO,IAAI;IACnD,MAAM,EAAE,OAAO,kBAAkB,CAAC;IAClC,uDAAuD;IACvD,EAAE,EAAE,SAAS,CAAC;IACd,sEAAsE;IACtE,GAAG,EAAE,CAAC,CAAC;CACR,CAAC;AAEF;8DAC8D;AAC9D,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,OAAO,GACZ,IAAI,IAAI,yBAAyB,CAAC,CAAC,CAAC,CAOtC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,EAAE,EACT,WAAW,EAAE,GAAG,CAAC,SAAS,CAAC,EAC3B,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,SAAS,GAC9B,KAAK,CAAC,CAAC,GAAG,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAoBzC"}

package/dist-lib/src/components/ui/DataTable/utils/filter-ops.d.ts

@@ -0,0 +1,41 @@
+import { DataTableColumnDef, FilterOperator } from '../data-table.types';
+/**
+ * Operadores que carregam MÚLTIPLOS valores numa condição (chip+popover) —
+ * multiSelect/tags. O FilterModel guarda 1 item por valor (spread).
+ */
+export declare const MULTI_VALUE_OPERATORS: Set<FilterOperator>;
+/** ID estável pra um FilterItem — `crypto.randomUUID()` com fallback timestamp. */
+export declare function genFilterId(): string;
+/**
+ * True quando um `FilterValue` é "vazio" (sem efeito) — null/undefined, string
+ * vazia, ou tupla/array com todos os sides nulos/strings vazias.
+ *
+ * ⚠️ Checa só o VALUE. Pra saber se um FilterItem está ATIVO (operadores
+ * `isEmpty`/`isNotEmpty` são ativos sem valor), use a lógica do processor.
+ */
+export declare function filterValueIsEmpty(v: unknown): boolean;
+/**
+ * Promove operador escalar → multi quando a coluna é `filterType: "multiSelect"`.
+ *
+ * Invariante: coluna multiSelect SEMPRE usa `isAnyOf`/`isNoneOf` (o widget
+ * MultiSelectFieldDropdown sempre togglea com array). Sem isso, presets
+ * declarados como `{ field, value }` (operator default `equals`) ou shortcuts
+ * de header ficam com operator escalar inconsistente — chip mostra
+ * "Status = active, pending" em vez de "é um de", e o filterModel cria N items
+ * separados em vez de 1 grupo.
+ *
+ * - `equals` → `isAnyOf`
+ * - `neq`    → `isNoneOf`
+ * - demais operadores / colunas não-multiSelect → inalterados
+ */
+export declare function promoteOperatorForFilterType(operator: FilterOperator, filterType: string | undefined): FilterOperator;
+/** Conveniência: mesma promoção a partir de uma `DataTableColumnDef`. */
+export declare function promoteOperatorForColumn<T>(operator: FilterOperator, col: DataTableColumnDef<T> | undefined): FilterOperator;
+/**
+ * Operador default de um tipo de filtro — derivado do REGISTRY (`operators[0]`),
+ * fonte única. Sem switch hardcoded: um column-type novo já traz seu default
+ * correto (ex: currency → equals, date → between, multiSelect → isAnyOf), e
+ * nunca cai num `"contains"` que o tipo não suporta.
+ */
+export declare function defaultOperatorForFilterType(filterType: string | undefined): FilterOperator;
+//# sourceMappingURL=filter-ops.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/filter-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-ops.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/filter-ops.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EACf,MAAM,qBAAqB,CAAC;AAG7B;;;GAGG;AACH,eAAO,MAAM,qBAAqB,qBAGhC,CAAC;AAEH,mFAAmF;AACnF,wBAAgB,WAAW,IAAI,MAAM,CAKpC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAStD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,cAAc,EACxB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,cAAc,CAKhB;AAED,yEAAyE;AACzE,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,QAAQ,EAAE,cAAc,EACxB,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,SAAS,GACrC,cAAc,CAEhB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,cAAc,CAGhB"}

package/dist-lib/src/components/ui/DataTable/utils/group-rows.d.ts

@@ -0,0 +1,59 @@
+import { DataTableColumnDef } from '../data-table.types';
+/** Marker symbol pra distinguir GroupRow de data row T no render branching.
+ *  Pattern symbol-as-discriminator evita conflito acidental com props do T. */
+export declare const GROUP_ROW_TYPE: unique symbol;
+/** Marker symbol pra "slot de conteúdo customizado do grupo" — quando consumer
+ *  passa renderGroupContent, esse marker substitui as N child rows por 1 row
+ *  full-width que delega 100% pro render do consumer. */
+export declare const GROUP_CONTENT_TYPE: unique symbol;
+/** Row sintética inserida no array antes de cada grupo. */
+export type DataTableGroupRow<T = unknown> = {
+    __type: typeof GROUP_ROW_TYPE;
+    /** Field usado pra agrupar (== props.groupBy). */
+    field: string;
+    /** Valor raw do grupo (ex: "active", "inactive"). */
+    value: unknown;
+    /** Label formatado pra display (passa por column.valueFormatter se houver). */
+    label: string;
+    /** Quantidade de rows nesse grupo. */
+    count: number;
+    /** Rows do grupo — usado pra subtotalizers + selectGroup. */
+    rows: T[];
+    /** Está expandido? Se false, child rows são skipped do array. */
+    isExpanded: boolean;
+    /** Chave unica do grupo — `${field}|${value}` */
+    key: string;
+};
+/** "Content slot" marker — substitui as child rows quando consumer passa
+ *  renderGroupContent. Carrega referência ao group pra que o consumer tenha
+ *  acesso a label/count/rows no callback. */
+export type DataTableGroupContent<T = unknown> = {
+    __type: typeof GROUP_CONTENT_TYPE;
+    /** Mesma key do group pai. */
+    key: string;
+    /** Referência ao group pai (label, count, rows). */
+    group: DataTableGroupRow<T>;
+};
+/** Type guard pra GroupRow. */
+export declare function isGroupRow<T>(row: T | DataTableGroupRow<T> | DataTableGroupContent<T>): row is DataTableGroupRow<T>;
+/** Type guard pra GroupContent (slot custom). */
+export declare function isGroupContent<T>(row: T | DataTableGroupRow<T> | DataTableGroupContent<T>): row is DataTableGroupContent<T>;
+/**
+ * Reshape do array de rows em (GroupRow | T)[] alternados.
+ *
+ * Ordem: groups aparecem na ordem da primeira ocorrencia (não sortado por label).
+ * Pra ordem específica, consumer pode passar rows já ordenadas pelo group field.
+ *
+ * Rows com value `undefined`/`null` no field caem no grupo "(sem valor)".
+ *
+ * @param rows Rows já filtradas/buscadas/ordenadas (output do processor)
+ * @param field Campo de agrupamento (== props.groupBy)
+ * @param expandedKeys Set de keys de grupos expandidos
+ * @param defaultExpanded Quando grupo NÃO está em expandedKeys, este é o estado default
+ * @param col Column def do field — usada pra valueGetter e valueFormatter
+ */
+export declare function groupRows<T>(rows: T[], field: string, expandedKeys: Set<string>, defaultExpanded: boolean, col: DataTableColumnDef<T> | undefined, 
+/** Quando true, substitui as N child rows por 1 GroupContent marker.
+ *  Consumer renderiza conteúdo livre via renderGroupContent. */
+useCustomContent?: boolean): Array<DataTableGroupRow<T> | DataTableGroupContent<T> | T>;
+//# sourceMappingURL=group-rows.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/group-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-rows.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/group-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D;+EAC+E;AAC/E,eAAO,MAAM,cAAc,eAAyB,CAAC;AAErD;;yDAEyD;AACzD,eAAO,MAAM,kBAAkB,eAA6B,CAAC;AAE7D,2DAA2D;AAC3D,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI;IAC3C,MAAM,EAAE,OAAO,cAAc,CAAC;IAC9B,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;IACf,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,iEAAiE;IACjE,UAAU,EAAE,OAAO,CAAC;IACpB,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;6CAE6C;AAC7C,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,OAAO,IAAI;IAC/C,MAAM,EAAE,OAAO,kBAAkB,CAAC;IAClC,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAC7B,CAAC;AAEF,+BAA+B;AAC/B,wBAAgB,UAAU,CAAC,CAAC,EAC1B,GAAG,EAAE,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,GACvD,GAAG,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAO7B;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAC9B,GAAG,EAAE,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,GACvD,GAAG,IAAI,qBAAqB,CAAC,CAAC,CAAC,CAOjC;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,CAAC,EAAE,EACT,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,eAAe,EAAE,OAAO,EACxB,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,SAAS;AACtC;gEACgE;AAChE,gBAAgB,UAAQ,GACvB,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CA0D5D"}

package/dist-lib/src/components/ui/DataTable/utils/measure-text.d.ts

@@ -0,0 +1,19 @@
+/**
+ * measure-text.ts — Canvas-based text measurement utility.
+ *
+ * Singleton canvas reutilizado entre todas as chamadas — evita custo de criar
+ * canvas a cada medição. SSR-safe (retorna 0 quando `window` não existe).
+ *
+ * Usado por `calculateColumnWidths` (Layer 2 — Smart Content Sampling) pra
+ * descobrir a largura ideal de uma coluna baseada no header + amostra de rows.
+ */
+/**
+ * Mede a largura em pixels de um texto na fonte default do DS.
+ * Reutiliza um canvas singleton para evitar overhead de criação.
+ *
+ * @param text — texto a medir
+ * @param font — font shorthand CSS (default: 13px Geist)
+ * @returns largura em pixels (0 se SSR ou texto vazio)
+ */
+export declare function measureTextWidth(text: string, font?: string): number;
+//# sourceMappingURL=measure-text.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/measure-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-text.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/measure-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmBH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAKpE"}

package/dist-lib/src/components/ui/DataTable/utils/resolve-value.d.ts

@@ -0,0 +1,19 @@
+import { DataTableColumnDef } from '../data-table.types';
+/**
+ * Helpers compartilhados de resolução de valor de cell.
+ *
+ * Antes da consolidação, 3 lugares duplicavam lógica:
+ *  - data-table.tsx → `resolveCellValue` (cell render)
+ *  - hooks/use-data-table-processor.ts → `getFieldValue` + `applyValueGetter` + `applyFormatter` (filter/sort/search)
+ *  - utils/group-rows.ts → `resolveGroupValue` (agrupamento)
+ *
+ * Agora todos consomem daqui — single source of truth pra dot-path lookup,
+ * valueGetter, e valueFormatter.
+ */
+/** Acessa valor em row via dot-path (`user.name`) ou key simples. */
+export declare function getFieldValue<T>(row: T, field: string): unknown;
+/** Resolve valor da cell: prioriza `column.valueGetter`, senão dot-path do field. */
+export declare function applyValueGetter<T>(row: T, column: DataTableColumnDef<T>): unknown;
+/** Resolve string formatada: pega valor + aplica `column.valueFormatter` se houver. */
+export declare function applyFormatter<T>(row: T, column: DataTableColumnDef<T>): string;
+//# sourceMappingURL=resolve-value.d.ts.map

package/dist-lib/src/components/ui/DataTable/utils/resolve-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-value.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/DataTable/utils/resolve-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;;;;;;;;;GAUG;AAEH,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAU/D;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAGlF;AAED,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,MAAM,CAI/E"}