forlogic-core 2.2.8 → 2.3.1

package/dist/sign/crud/createSimpleService.d.ts

@@ -0,0 +1,85 @@
+import { QualiexUserFieldMapping } from '../types';
+interface SimpleServiceConfig {
+    tableName: string;
+    entityName: string;
+    schemaName?: string;
+    searchFields?: string[];
+    selectFields?: string;
+    enableQualiexEnrichment?: boolean;
+    /** Lista simples de campos de ID (ex: ['target_user_id', 'evaluator_user_id']) */
+    userIdFields?: string[];
+    /** Mapeamento granular de campos (sobrescreve userIdFields se presente) */
+    userFieldsMapping?: QualiexUserFieldMapping[];
+}
+/**
+ * Cria um serviço CRUD completo com hook React Query
+ *
+ * Gera automaticamente service + hook integrado com cache, soft delete e RLS.
+ *
+ * @example
+ * ```typescript
+ * const { service, useCrudHook } = createSimpleService<Example>({
+ *   tableName: 'examples',
+ *   entityName: 'exemplo',
+ *   searchFields: ['title', 'description'],
+ *   enableQualiexEnrichment: true
+ * });
+ * ```
+ *
+ * Ver README para documentação completa sobre RLS policies e estrutura de tabela
+ */
+export declare function createSimpleService<T extends {
+    id: string;
+    id_user?: string | null;
+}, TInsert = any, TUpdate = any>(config: SimpleServiceConfig): {
+    service: {
+        getAll(params?: import("..").QueryParams): Promise<import("..").PaginatedResponse<T & {
+            responsible_name?: string;
+        }>>;
+        getById(id: string): Promise<T>;
+        create(payload: TInsert): Promise<T>;
+        update(id: string, payload: TUpdate): Promise<T>;
+        delete(id: string): Promise<void>;
+    };
+    useCrudHook: (additionalFilters?: Record<string, any>, onSuccess?: () => void) => {
+        entities: any;
+        pagination: {
+            data: any;
+            currentPage: any;
+            totalPages: any;
+            totalItems: any;
+            itemsPerPage: any;
+            hasNextPage: any;
+            hasPreviousPage: any;
+        };
+        isLoading: boolean;
+        isCreating: boolean;
+        isUpdating: boolean;
+        isDeleting: boolean;
+        error: Error;
+        searchTerm: string;
+        sortField: string;
+        sortDirection: "desc" | "asc";
+        currentPage: number;
+        itemsPerPage: number;
+        queryKey: string;
+        createEntity: import("@tanstack/react-query").UseMutateFunction<T, any, TInsert, unknown>;
+        updateEntity: (id: string, data: TUpdate) => void;
+        deleteEntity: import("@tanstack/react-query").UseMutateFunction<void, any, string, unknown>;
+        save: (data: any, transform?: (data: any) => any) => void;
+        handleSearch: (search: string) => void;
+        handleSort: (field: string) => void;
+        handlePageChange: (newPage: number) => void;
+        handleItemsPerPageChange: (newLimit: number) => void;
+        clearFilters: () => void;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<any, Error>>;
+        selectedIds: string[];
+        selectItem: (id: string) => void;
+        selectAll: () => void;
+        clearSelection: () => void;
+        isAllSelected: boolean;
+        bulkDelete: (ids: string[]) => Promise<void>;
+        isBulkDeleting: boolean;
+    };
+};
+export {};

package/dist/sign/crud/generateCrudConfig.d.ts

@@ -0,0 +1,78 @@
+import { GeneratedCrudConfig, EntityWithId } from '../types';
+/**
+ * Gera automaticamente configuração CRUD a partir de uma interface TypeScript.
+ *
+ * **USO AVANÇADO:** Para a maioria dos casos, prefira config manual memoizada com
+ * `useMemo` (ver {@link createCrudPage}). Esta função é útil para gerar configs
+ * dinamicamente em runtime a partir de uma entidade-amostra.
+ *
+ * @remarks
+ * A inferência roda em runtime via `Object.keys(sampleEntity)` — campos que não estão
+ * presentes em `sampleEntity` (ainda que existam no tipo `T`) **não geram coluna**.
+ * Sempre passe um objeto com todas as chaves desejadas, mesmo com valores vazios/zero.
+ *
+ * Heurísticas de tipo:
+ * - Nome do campo (ex: "email" → `type: 'email'`, "description" → `type: 'textarea'`).
+ * - Tipo do valor (boolean/number/Date).
+ *
+ * @see {@link createCrudPage} para o fluxo recomendado.
+ *
+ * @example
+ * ```typescript
+ * interface Employee {
+ *   id: string;
+ *   name: string;
+ *   email: string;
+ *   is_active: boolean;
+ *   description: string;
+ *   created_at: string;
+ * }
+ *
+ * const config = generateCrudConfig<Employee>(
+ *   'Funcionários',
+ *   { name: '', email: '', is_active: true, description: '' }
+ * );
+ *
+ * // Resultado:
+ * // {
+ * //   title: 'Funcionários',
+ * //   columns: [
+ * //     { key: 'name', header: 'Name', type: 'text', sortable: true },
+ * //     { key: 'email', header: 'Email', type: 'email', sortable: true },
+ * //     { key: 'is_active', header: 'Is Active', type: 'boolean' },
+ * //     { key: 'description', header: 'Description', type: 'textarea' }
+ * //   ],
+ * //   searchPlaceholder: 'Buscar funcionários...',
+ * //   enableCreate: true,
+ * //   enableEdit: true,
+ * //   enableDelete: true
+ * // }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Com overrides para customizar
+ * const config = generateCrudConfig<Employee>(
+ *   'Funcionários',
+ *   { name: '', email: '', status: 'active' },
+ *   {
+ *     enableDelete: false,  // Desabilita exclusão
+ *     itemsPerPage: 25,     // Customiza paginação
+ *     columns: [            // Sobrescreve colunas específicas
+ *       { key: 'status', header: 'Status', type: 'select',
+ *         options: ['active', 'inactive', 'pending'] }
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @param title Título da página/entidade (ex: 'Funcionários')
+ * @param sampleEntity Objeto com campos da entidade (valores podem ser vazios)
+ * @param overrides Sobrescreve configurações auto-geradas
+ *
+ * @returns Configuração CRUD completa pronta para usar com createCrudPage
+ *
+ * @see {@link withPreset} - Para usar presets prontos (user, product, order, category)
+ * @see {@link crudPresets} - Presets disponíveis
+ */
+export declare function generateCrudConfig<T extends EntityWithId>(title: string, sampleEntity: Partial<T>, overrides?: Partial<GeneratedCrudConfig<T>>): GeneratedCrudConfig<T>;

package/dist/sign/crud/hooks/useBaseForm.d.ts

@@ -0,0 +1,47 @@
+import { FormField } from '../../types';
+/**
+ * Hook que gerencia estado, validação e defaults de um formulário declarativo (FormField[]).
+ *
+ * É o motor interno do {@link BaseForm} — exporte para reaproveitar o sistema de campos
+ * fora do `Dialog` padrão (ex: forms inline, wizards, drawers).
+ *
+ * Aplica defaults por tipo (`text` → `''`, `switch` → `false`, `multiselect` → `[]`, etc.)
+ * e expõe `setField`, `validate` e `reset`.
+ *
+ * @example
+ * const fields: FormField[] = [
+ *   { key: 'title', label: 'Título', type: 'text', required: true },
+ *   { key: 'is_active', label: 'Ativo', type: 'switch', defaultValue: true },
+ * ];
+ *
+ * function MyDrawerForm({ initial, onSave }) {
+ *   const { formData, errors, setField, validate, reset } = useBaseForm(
+ *     fields,
+ *     initial,
+ *     (data) => console.log('changed', data),
+ *     true, // open
+ *   );
+ *
+ *   const handleSubmit = () => {
+ *     if (validate()) onSave(formData);
+ *   };
+ *
+ *   return (
+ *     <>
+ *       <Input
+ *         value={formData.title ?? ''}
+ *         onChange={(e) => setField('title', e.target.value)}
+ *         error={errors.title}
+ *       />
+ *       <Button onClick={handleSubmit}>Salvar</Button>
+ *     </>
+ *   );
+ * }
+ */
+export declare function useBaseForm<T extends Record<string, any>>(fields: FormField[], initialData?: Partial<T>, onFormDataChange?: (data: T) => void, open?: boolean): {
+    formData: T;
+    errors: Record<string, string>;
+    updateField: (fieldName: string, value: any) => void;
+    validateForm: () => boolean;
+    handleSubmit: (onSubmit: (data: T) => void) => (e?: React.FormEvent) => void;
+};

package/dist/sign/crud/hooks/useColumnDragReorder.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+export interface UseColumnDragReorderOptions {
+    enabled?: boolean;
+    onReorder: (fromIndex: number, toIndex: number) => void;
+}
+export interface UseColumnDragReorderReturn {
+    dragFromIndex: number | null;
+    dragOverIndex: number | null;
+    isDragging: boolean;
+    getDragProps: (index: number, columnKey?: string) => {
+        draggable: boolean;
+        onDragStart: (e: React.DragEvent) => void;
+        onDragOver: (e: React.DragEvent) => void;
+        onDragEnter: (e: React.DragEvent) => void;
+        onDrop: (e: React.DragEvent) => void;
+        onDragEnd: () => void;
+    };
+}
+export declare function useColumnDragReorder({ enabled, onReorder, }: UseColumnDragReorderOptions): UseColumnDragReorderReturn;

package/dist/sign/crud/hooks/useColumnManager.d.ts

@@ -0,0 +1,85 @@
+import type { CrudColumn, BaseEntity } from '../../types';
+/**
+ * Tipo `ColumnManagerState` exportado pela lib.
+ * @example
+ * const value: ColumnManagerState = {} as ColumnManagerState;
+ */
+export interface ColumnManagerState {
+    hiddenColumns: Set<string>;
+    columnOrder: string[];
+    groupByColumns: string[];
+}
+/**
+ * Tipo `UseColumnManagerOptions` exportado pela lib.
+ * @example
+ * const value: UseColumnManagerOptions = {} as UseColumnManagerOptions;
+ */
+export interface UseColumnManagerOptions<T> {
+    columns: CrudColumn<T>[];
+    storageKey?: string;
+    enabled?: boolean;
+    /** Column keys to hide by default (before any user interaction). Only applied when no saved state exists. */
+    defaultHiddenColumns?: string[];
+}
+/**
+ * Tipo `UseColumnManagerReturn` exportado pela lib.
+ * @example
+ * const value: UseColumnManagerReturn = {} as UseColumnManagerReturn;
+ */
+export interface UseColumnManagerReturn<T> {
+    /** Columns filtered by visibility and reordered */
+    visibleColumns: CrudColumn<T>[];
+    /** All original columns (for the settings popover) */
+    allColumns: CrudColumn<T>[];
+    /** Whether a column is hidden */
+    isColumnHidden: (key: string) => boolean;
+    /** Toggle column visibility */
+    toggleColumn: (key: string) => void;
+    /** Show all columns */
+    showAllColumns: () => void;
+    /** Reset columns to default order and visibility */
+    resetColumns: () => void;
+    /** Current column order (keys) */
+    columnOrder: string[];
+    /** Reorder columns */
+    reorderColumns: (fromIndex: number, toIndex: number) => void;
+    /** @deprecated Use groupByColumns instead */
+    groupByColumn: string | null;
+    /** @deprecated Use setGroupByColumns / addGroupByColumn instead */
+    setGroupByColumn: (key: string | null) => void;
+    /** Current group-by columns (ordered, multi-level) */
+    groupByColumns: string[];
+    /** Set all group-by columns at once */
+    setGroupByColumns: (keys: string[]) => void;
+    /** Add a column to grouping (appends at end) */
+    addGroupByColumn: (key: string) => void;
+    /** Remove a column from grouping */
+    removeGroupByColumn: (key: string) => void;
+    /** Reorder group-by columns */
+    reorderGroupByColumns: (fromIndex: number, toIndex: number) => void;
+    /** Groups computed from data (supports multi-level) */
+    getGroupedData: (data: T[]) => GroupedData<T>[];
+    /** Collapsed group keys */
+    collapsedGroups: Set<string>;
+    /** Toggle group collapse */
+    toggleGroupCollapse: (groupKey: string) => void;
+}
+/**
+ * Tipo `GroupedData` exportado pela lib.
+ * @example
+ * const value: GroupedData = {} as GroupedData;
+ */
+export interface GroupedData<T> {
+    groupKey: string;
+    groupValue: string;
+    items: T[];
+    count: number;
+    level: number;
+    children?: GroupedData<T>[];
+}
+/**
+ * Função utilitária `useColumnManager`.
+ * @example
+ * useColumnManager();
+ */
+export declare function useColumnManager<T extends BaseEntity>({ columns, storageKey, enabled, defaultHiddenColumns, }: UseColumnManagerOptions<T>): UseColumnManagerReturn<T>;

package/dist/sign/crud/hooks/useCrud.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Hook genérico para operações CRUD com React Query
+ *
+ * **USO AVANÇADO** - Para a maioria dos casos, use `createSimpleService` que já retorna este hook.
+ *
+ * Fornece gerenciamento completo de estado para operações CRUD:
+ * - ✅ Busca, ordenação e paginação via URL params
+ * - ✅ Cache inteligente com React Query
+ * - ✅ Mutations com feedback automático (toasts)
+ * - ✅ Seleção múltipla e ações em massa
+ * - ✅ Invalidação automática de cache
+ * - ✅ Estados de loading separados por operação
+ *
+ * @example
+ * ```typescript
+ * // Normalmente você NÃO usa este hook diretamente, mas sim via createSimpleService:
+ * const { useCrudHook } = createSimpleService({ tableName: 'employees', ... });
+ * const manager = useCrudHook();
+ *
+ * // manager retorna:
+ * const {
+ *   entities,           // Array de dados
+ *   isLoading,          // Loading inicial
+ *   isCreating,         // Loading ao criar
+ *   isUpdating,         // Loading ao atualizar
+ *   isDeleting,         // Loading ao deletar
+ *
+ *   createEntity,       // Função para criar
+ *   updateEntity,       // Função para atualizar
+ *   deleteEntity,       // Função para deletar
+ *
+ *   pagination: {
+ *     currentPage,
+ *     totalPages,
+ *     totalItems,
+ *     hasNextPage
+ *   },
+ *
+ *   handleSearch,       // Função para busca
+ *   handleSort,         // Função para ordenação
+ *   handlePageChange,   // Função para paginação
+ *
+ *   selectedIds,        // IDs selecionados (bulk)
+ *   selectAll,          // Selecionar todos
+ *   bulkDelete          // Deletar selecionados
+ * } = manager;
+ * ```
+ *
+ * @param config Configuração do hook
+ * @param config.queryKey Chave única para cache do React Query
+ * @param config.service Service com métodos getAll, create, update, delete
+ * @param config.entityName Nome da entidade para mensagens de toast
+ * @param config.searchFields Campos para busca (opcional, default no service)
+ * @param config.additionalFilters Filtros adicionais sempre aplicados
+ * @param config.onSuccess Callback executado após create/update com sucesso
+ *
+ * @returns Manager completo com dados, estados e funções de CRUD
+ *
+ * @see {@link createSimpleService} - Método recomendado que já usa este hook
+ */
+interface CrudService<T, TInsert = Partial<T>, TUpdate = Partial<T>> {
+    getAll: (params: any) => Promise<any>;
+    create: (data: TInsert) => Promise<T>;
+    update: (id: string, data: TUpdate) => Promise<T>;
+    delete: (id: string) => Promise<void>;
+}
+interface CrudConfig<T, TInsert = Partial<T>, TUpdate = Partial<T>> {
+    queryKey: string;
+    service: CrudService<T, TInsert, TUpdate>;
+    entityName: string;
+    searchFields?: string[];
+    additionalFilters?: Record<string, any>;
+    onSuccess?: () => void;
+}
+/**
+ * Hook genérico para operações CRUD com React Query (busca, paginação, mutations, bulk).
+ *
+ * **Uso recomendado**: invoque via `createSimpleService` — ele já configura `queryKey` e `service`.
+ * Use diretamente apenas quando precisar de um service customizado (RPC, edge function, etc).
+ *
+ * @example
+ * // Via createSimpleService (recomendado)
+ * const { useCrudHook } = createSimpleService<Employee>({
+ *   tableName: 'employees',
+ *   schema: 'central',
+ *   searchFields: ['name', 'email'],
+ * });
+ * const manager = useCrudHook();
+ *
+ * @example
+ * // Uso direto com service customizado
+ * const manager = useCrud<Project>({
+ *   queryKey: 'projects',
+ *   entityName: 'projeto',
+ *   service: {
+ *     getAll: (params) => projectsApi.list(params),
+ *     create: (data) => projectsApi.create(data),
+ *     update: (id, data) => projectsApi.update(id, data),
+ *     delete: (id) => projectsApi.softDelete(id),
+ *   },
+ *   additionalFilters: { id_status: 'active' },
+ *   onSuccess: () => navigate('/projects'),
+ * });
+ *
+ * @example
+ * // Consumindo o manager retornado
+ * const { entities, isLoading, createEntity, deleteEntity, pagination, handleSort } = manager;
+ * <Button onClick={() => createEntity({ title: 'Novo' })}>Criar</Button>
+ */
+export declare function useCrud<T extends {
+    id: string;
+}, TInsert = Partial<T>, TUpdate = Partial<T>>({ queryKey, service, entityName, searchFields, additionalFilters, onSuccess }: CrudConfig<T, TInsert, TUpdate>): {
+    entities: any;
+    pagination: {
+        data: any;
+        currentPage: any;
+        totalPages: any;
+        totalItems: any;
+        itemsPerPage: any;
+        hasNextPage: any;
+        hasPreviousPage: any;
+    };
+    isLoading: boolean;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    error: Error;
+    searchTerm: string;
+    sortField: string;
+    sortDirection: "desc" | "asc";
+    currentPage: number;
+    itemsPerPage: number;
+    queryKey: string;
+    createEntity: import("@tanstack/react-query").UseMutateFunction<T, any, TInsert, unknown>;
+    updateEntity: (id: string, data: TUpdate) => void;
+    deleteEntity: import("@tanstack/react-query").UseMutateFunction<void, any, string, unknown>;
+    save: (data: any, transform?: (data: any) => any) => void;
+    handleSearch: (search: string) => void;
+    handleSort: (field: string) => void;
+    handlePageChange: (newPage: number) => void;
+    handleItemsPerPageChange: (newLimit: number) => void;
+    clearFilters: () => void;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<any, Error>>;
+    selectedIds: string[];
+    selectItem: (id: string) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    isAllSelected: boolean;
+    bulkDelete: (ids: string[]) => Promise<void>;
+    isBulkDeleting: boolean;
+};
+export {};

package/dist/sign/crud/primitives/ActionMenu.d.ts

@@ -0,0 +1,69 @@
+/**
+ * ActionMenu Primitive Component
+ *
+ * Menu de ações reutilizável que pode ser renderizado como dropdown ou inline.
+ * Suporta ações padrão (Edit, Delete, Toggle) e ações customizadas.
+ *
+ * @example
+ * ```tsx
+ * // Dropdown (padrão)
+ * <ActionMenu
+ *   onEdit={() => console.log('edit')}
+ *   onDelete={() => console.log('delete')}
+ *   renderAs="dropdown"
+ * />
+ *
+ * // Inline com ações customizadas
+ * <ActionMenu
+ *   onEdit={() => console.log('edit')}
+ *   customActions={[
+ *     { label: 'Duplicar', icon: Copy, onClick: () => {}, variant: 'default' }
+ *   ]}
+ *   renderAs="inline"
+ *   variant="compact"
+ * />
+ * ```
+ */
+import type { ActionMenuProps } from './types';
+/**
+ * Menu de ações por linha — renderiza dropdown (`renderAs="dropdown"`) ou botões inline
+ * (`renderAs="inline"`). Acoplado às convenções do CRUD (Edit / Delete / Toggle Status)
+ * mas extensível via `customActions`.
+ *
+ * Para tabelas inteiras, prefira a prop `rowActions` do `CrudTable` — só use este primitive
+ * quando precisar de um menu fora do contexto de tabela.
+ *
+ * @example
+ * // Dropdown padrão (3 dots) com Edit + Delete
+ * <ActionMenu
+ *   onEdit={() => openEdit(row)}
+ *   onDelete={() => confirmDelete(row.id)}
+ *   canDelete={row.id_user === currentUser.id}
+ * />
+ *
+ * @example
+ * // Inline compacto com ações customizadas + bloqueio condicional
+ * <ActionMenu
+ *   renderAs="inline"
+ *   variant="compact"
+ *   onEdit={() => openEdit(row)}
+ *   customActions={[
+ *     { label: 'Duplicar', icon: Copy, onClick: () => duplicate(row) },
+ *     {
+ *       label: 'Arquivar',
+ *       icon: Archive,
+ *       onClick: () => archive(row),
+ *       disabled: row.status === 'completed',
+ *       disabledReason: 'Planos concluídos não podem ser arquivados',
+ *     },
+ *   ]}
+ * />
+ *
+ * @example
+ * // Toggle de status (ativar/desativar) com ícone dinâmico
+ * <ActionMenu
+ *   onToggleStatus={() => toggleActive(row.id)}
+ *   isActive={row.is_actived}
+ * />
+ */
+export declare function ActionMenu({ onEdit, onDelete, onToggleStatus, isActive, canEdit, canDelete, customActions, renderAs, variant }: ActionMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/crud/primitives/FilterBar.d.ts

@@ -0,0 +1,69 @@
+/**
+ * FilterBar Primitive Component
+ *
+ * Barra de filtros reutilizável com campo de busca e slots para filtros customizados.
+ *
+ * @example
+ * ```tsx
+ * <FilterBar
+ *   searchValue={search}
+ *   onSearchChange={setSearch}
+ *   customFilters={[
+ *     <StatusSelect value={status} onChange={setStatus} />,
+ *     <CategorySelect value={category} onChange={setCategory} />
+ *   ]}
+ *   onClearFilters={() => {
+ *     setSearch('');
+ *     setStatus('all');
+ *     setCategory('all');
+ *   }}
+ * />
+ * ```
+ */
+import type { FilterBarProps } from './types';
+/**
+ * Barra de filtros primitiva: busca textual + slots para filtros customizados (selects,
+ * date ranges, etc) + botão "Limpar filtros" automático.
+ *
+ * Para CRUDs completos, prefira `CrudActionBar` (já integra com o manager). Use este
+ * primitive apenas para listas/dashboards fora do pipeline CRUD.
+ *
+ * Ver `mem://patterns/primitive-search-strategies` para a diferença entre busca local
+ * (`DataFilterBar`) e busca global (`AppHeader`).
+ *
+ * @example
+ * // Busca + 2 filtros customizados horizontais
+ * const [search, setSearch] = useState('');
+ * const [status, setStatus] = useState('all');
+ * const [responsible, setResponsible] = useState<string | null>(null);
+ *
+ * <FilterBar
+ *   searchValue={search}
+ *   onSearchChange={setSearch}
+ *   customFilters={[
+ *     <Combobox
+ *       key="status"
+ *       options={statusOptions}
+ *       value={status}
+ *       onChange={setStatus}
+ *       placeholder="Status"
+ *     />,
+ *     <QualiexUserField
+ *       key="responsible"
+ *       value={responsible}
+ *       onChange={setResponsible}
+ *       placeholder="Responsável"
+ *     />,
+ *   ]}
+ *   onClearFilters={() => {
+ *     setSearch('');
+ *     setStatus('all');
+ *     setResponsible(null);
+ *   }}
+ * />
+ *
+ * @example
+ * // Layout vertical (sidebar de filtros)
+ * <FilterBar layout="vertical" searchValue={s} onSearchChange={setS} customFilters={[...]} />
+ */
+export declare function FilterBar({ searchValue, onSearchChange, customFilters, onClearFilters, showClearButton, layout }: FilterBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/crud/primitives/Pagination.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pagination Primitive Component
+ *
+ * Controles de paginação reutilizáveis sem dependências de CRUD logic.
+ *
+ * Layout Visual: 3 colunas responsivas
+ * [Itens por página: 10 ▼]    [1-10 de 100 itens (página 1 de 10)]    [<< < | 1 de 10 | > >>]
+ *      └─ Esquerda                        └─ Centro                          └─ Direita
+ *
+ * @example
+ * ```tsx
+ * <Pagination
+ *   currentPage={1}
+ *   totalPages={10}
+ *   totalItems={100}
+ *   itemsPerPage={10}
+ *   onPageChange={(page) => setPage(page)}
+ *   onItemsPerPageChange={(limit) => setLimit(limit)}
+ *   variant="full"
+ * />
+ * ```
+ */
+import type { PaginationProps } from "./types";
+/**
+ * Função utilitária `Pagination`.
+ * @example
+ * Pagination();
+ */
+export declare function Pagination({ currentPage, totalPages, totalItems, itemsPerPage, onPageChange, onItemsPerPageChange, variant, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/crud/primitives/Table.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Table Primitive Component
+ *
+ * Componente de tabela "puro" sem dependências de lógica CRUD.
+ * Responsável apenas por renderizar dados em formato tabular com sorting visual.
+ * Suporta redimensionamento de colunas via drag (habilitado por padrão).
+ *
+ * @example
+ * ```tsx
+ * <Table
+ *   data={users}
+ *   columns={[
+ *     { key: 'name', header: t('ap_name'), sortable: true },
+ *     { key: 'email', header: 'Email' }
+ *   ]}
+ *   sortField="name"
+ *   sortDirection="asc"
+ *   onSort={(field) => console.log('Sort by:', field)}
+ *   renderActions={(user) => <button>{t('edit')}</button>}
+ * />
+ * ```
+ */
+import type { TableProps } from './types';
+/**
+ * Função utilitária `Table`.
+ * @example
+ * Table();
+ */
+export declare function Table<T extends {
+    id: string;
+}>({ data, columns, sortField, sortDirection, onSort, onRowClick, renderActions, isLoading, emptyMessage, className, enableSelection, selectedIds, onSelectItem, onSelectAll, isAllSelected, enableColumnResize, onColumnResize, enableColumnReorder, onReorderColumns, storageKey, enableExpandableRows, renderExpandedContent, expandedRowIds: controlledExpandedIds, onToggleExpand: controlledToggleExpand, defaultExpandAll, rowActionsVariant, hideActionsColumn, actionsHeaderContent, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/sign/crud/primitives/TreeTable.d.ts

@@ -0,0 +1,7 @@
+import type { TreeNode, TreeTableProps } from './types';
+/**
+ * Função utilitária `TreeTable`.
+ * @example
+ * TreeTable();
+ */
+export declare function TreeTable<T extends TreeNode>({ data, columns, nameKey, nameHeader, iconComponent, expandedIds, onToggleExpand, onRowClick, renderActions, actionsHeader, rowActionsVariant, isLoading, emptyMessage, className, enableSelection, selectedIds: selectedIdsArray, onSelectItem, onSelectAll, isAllSelected, enableRowDrag, onMoveNode, onMoveNodes, rootDropLabel, actionsWidth, nameMinWidth, }: TreeTableProps<T>): import("react/jsx-runtime").JSX.Element;