forlogic-core 3.0.10 → 4.0.0

package/dist/crud/components/ColumnManagerMenu.d.ts

@@ -0,0 +1,56 @@
+import React from 'react';
+/**
+ * Item de coluna exibido no gerenciador.
+ */
+export interface ColumnManagerItem {
+    key: string;
+    label: React.ReactNode;
+    /** Se `false`, a coluna não pode ser oculta (checkbox desabilitado). */
+    hideable?: boolean;
+    /** Se `true`, exibe o botão de agrupar. */
+    groupable?: boolean;
+    grouped?: boolean;
+    visible: boolean;
+}
+/**
+ * Props do `ColumnManagerMenu`.
+ */
+export interface ColumnManagerMenuProps {
+    items: ColumnManagerItem[];
+    /** Alterna visibilidade da coluna. */
+    onToggle: (key: string) => void;
+    /** Move a coluna de `fromIndex` para `toIndex` (índices na ordem exibida). */
+    onReorder: (fromIndex: number, toIndex: number) => void;
+    onShowAll?: () => void;
+    onHideAll?: () => void;
+    onToggleGroup?: (key: string, grouped: boolean) => void;
+    /** Salva a configuração atual como padrão do usuário. */
+    onSaveAsDefault?: () => void;
+    /** Restaura o padrão (do usuário, se existir). */
+    onReset?: () => void;
+    hasCustomDefault?: boolean;
+    title?: string;
+    /** Conteúdo customizado do trigger. Se omitido, usa botão ícone padrão. */
+    trigger?: React.ReactNode;
+    align?: 'start' | 'center' | 'end';
+    labels?: Partial<{
+        columns: string;
+        hint: string;
+        selectAll: string;
+        clearAll: string;
+        saveDefault: string;
+        reset: string;
+        group: string;
+        ungroup: string;
+    }>;
+}
+/**
+ * ColumnManagerMenu
+ *
+ * Menu de contexto (popover) para gerenciar colunas: lista com drag & drop suave,
+ * indicador da área de soltura, seleção em massa, salvar padrão do usuário e restaurar.
+ *
+ * @example
+ * <ColumnManagerMenu items={items} onToggle={t} onReorder={r} />
+ */
+export declare function ColumnManagerMenu({ items, onToggle, onReorder, onShowAll, onHideAll, onToggleGroup, onSaveAsDefault, onReset, hasCustomDefault, trigger, align, labels, }: ColumnManagerMenuProps): React.JSX.Element;

package/dist/crud/components/ColumnSettingsPopover.d.ts

@@ -11,7 +11,10 @@ export interface ColumnSettingsPopoverProps<T> {
     isColumnHidden: (key: string) => boolean;
     toggleColumn: (key: string) => void;
     showAllColumns: () => void;
+    hideAllColumns?: () => void;
     resetColumns?: () => void;
+    saveAsDefault?: () => void;
+    hasCustomDefault?: boolean;
     reorderColumns: (fromIndex: number, toIndex: number) => void;
     /** @deprecated Use groupByColumns + addGroupByColumn + removeGroupByColumn */
     groupByColumn?: string | null;
@@ -22,8 +25,9 @@ export interface ColumnSettingsPopoverProps<T> {
     removeGroupByColumn?: (key: string) => void;
 }
 /**
- * Função utilitária `ColumnSettingsPopover`.
+ * Popover de configuração de colunas (visibilidade, ordem, agrupamento).
+ * Delegação para `ColumnManagerMenu`.
  * @example
- * ColumnSettingsPopover();
+ * <ColumnSettingsPopover columns={columns} {...columnManager} />
  */
-export declare function ColumnSettingsPopover<T extends BaseEntity>({ columns, columnOrder, isColumnHidden, toggleColumn, showAllColumns, reorderColumns, groupByColumn, setGroupByColumn, groupByColumns, addGroupByColumn, removeGroupByColumn, resetColumns, }: ColumnSettingsPopoverProps<T>): React.JSX.Element;
+export declare function ColumnSettingsPopover<T extends BaseEntity>({ columns, columnOrder, isColumnHidden, toggleColumn, showAllColumns, hideAllColumns, reorderColumns, groupByColumn, setGroupByColumn, groupByColumns, addGroupByColumn, removeGroupByColumn, resetColumns, saveAsDefault, hasCustomDefault, }: ColumnSettingsPopoverProps<T>): React.JSX.Element;

package/dist/crud/components/ContextMenu.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { type RowActionInput } from '../actions/useRowActions';
 import type { BaseEntity } from '../../types';
 interface ContextMenuProps<T extends BaseEntity> {
     contextMenu: {
@@ -10,12 +11,14 @@ interface ContextMenuProps<T extends BaseEntity> {
     onEdit?: (item: T) => void;
     onDelete?: (item: T) => void;
     onToggleStatus?: (item: T) => void;
-    customActions?: (item: T) => Array<{
-        icon: any;
-        label: string;
-        onClick: () => void;
-    }>;
+    customActions?: (item: T) => RowActionInput[];
 }
+/**
+ * Menu de contexto posicionado por coordenadas (x/y).
+ *
+ * Usa a mesma resolução de ações do `RowActions` (`useRowActions`), garantindo
+ * ordem, rótulos, variantes e agrupamento idênticos aos demais menus.
+ */
 export declare const ContextMenu: <T extends BaseEntity & {
     is_actived?: boolean;
 }>({ contextMenu, onClose, onEdit, onDelete, onToggleStatus, customActions, }: ContextMenuProps<T>) => React.JSX.Element;

package/dist/crud/components/CrudActionBar.d.ts

@@ -31,6 +31,8 @@ export interface CrudActionBarProps<T extends BaseEntity = BaseEntity> {
     onNew?: () => void;
     newButtonLabel?: string;
     showNewButton?: boolean;
+    /** Quando informado (não vazio), o botão "Novo" vira um SplitButton com essas ações no menu. */
+    newButtonActions?: CustomAction[];
     showSearch?: boolean;
     searchValue?: string;
     onSearchChange?: (value: string) => void;
@@ -49,7 +51,7 @@ export interface CrudActionBarProps<T extends BaseEntity = BaseEntity> {
     rightSlot?: React.ReactNode;
     className?: string;
 }
-declare function CrudActionBarComponent<T extends BaseEntity = BaseEntity>({ onNew, newButtonLabel, showNewButton, showSearch, searchValue, onSearchChange, searchPlaceholder, showBulkActions, selectedCount, bulkActions, onBulkDelete, onClearSelection, customActions, filters, viewMode, onViewModeChange, showViewToggle, availableViewModes, rightSlot, className, }: CrudActionBarProps<T>): React.JSX.Element;
+declare function CrudActionBarComponent<T extends BaseEntity = BaseEntity>({ onNew, newButtonLabel, showNewButton, newButtonActions, showSearch, searchValue, onSearchChange, searchPlaceholder, showBulkActions, selectedCount, bulkActions, onBulkDelete, onClearSelection, customActions, filters, viewMode, onViewModeChange, showViewToggle, availableViewModes, rightSlot, className, }: CrudActionBarProps<T>): React.JSX.Element;
 /**
  * Componente `CrudActionBar` da lib.
  * @example

package/dist/crud/components/CrudGrid.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { CrudColumn, CrudManager, BaseEntity, BulkAction } from '../../types';
+import type { RowActionsState } from '../actions/useRowActions';
 import { type CustomAction, type ViewMode } from './CrudActionBar';
 /**
  * Tipo `CrudGridProps` exportado pela lib.
@@ -22,6 +23,11 @@ export interface CrudGridProps<T extends BaseEntity & {
         onClick: () => void;
     }>;
     enableBulkActions?: boolean;
+    /**
+     * Convenção única de ações condicionais por item (mesma do `CrudTable`):
+     * `can*: false` oculta a ação; `*Disabled: true` mantém visível e bloqueada.
+     */
+    rowActionsState?: (item: T) => RowActionsState;
     onNew?: () => void;
     newButtonLabel?: string;
     showNewButton?: boolean;
@@ -49,5 +55,5 @@ export interface CrudGridProps<T extends BaseEntity & {
  * @example
  * <CrudGrid />
  */
-export declare const CrudGrid: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, enableBulkActions, onNew, newButtonLabel, showNewButton, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, gridColumns, renderCard, viewMode, onViewModeChange, listCardRenderer, gridCardRenderer, showViewToggle }: CrudGridProps<T>) => React.JSX.Element;
+export declare const CrudGrid: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, rowActionsState, enableBulkActions, onNew, newButtonLabel, showNewButton, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, gridColumns, renderCard, viewMode, onViewModeChange, listCardRenderer, gridCardRenderer, showViewToggle }: CrudGridProps<T>) => React.JSX.Element;
 export default CrudGrid;

package/dist/crud/components/CrudTable.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { CrudColumn, CrudManager, BaseEntity, BulkAction } from '../../types';
+import type { RowActionInput, RowActionsState } from '../actions/useRowActions';
 import { type CustomAction, type ViewMode } from './CrudActionBar';
 export interface CrudTableProps<T extends BaseEntity & {
     is_actived?: boolean;
@@ -11,17 +12,22 @@ export interface CrudTableProps<T extends BaseEntity & {
     onToggleStatus?: (item: T) => void;
     onDelete?: (item: T) => void;
     renderActions?: (item: T) => React.ReactNode;
-    customRowActions?: (item: T) => Array<{
-        icon: any;
-        label: string;
-        onClick: () => void;
-    }>;
+    /** Ações extras por linha. Use `quick: true/false` para controlar se vira ícone rápido. */
+    customRowActions?: (item: T) => RowActionInput[];
     enableBulkActions?: boolean;
-    /** Variante de ações por linha: 'dropdown' (padrão) ou 'inline' (hover estilo Google Drive) */
-    rowActionsVariant?: 'dropdown' | 'inline';
+    /**
+     * Variante de ações por linha (padrão `hover`):
+     * - `hover`: até 3 ícones rápidos revelados no hover da linha + menu ⋮;
+     * - `always`: ícones rápidos sempre visíveis + menu ⋮;
+     * - `menu`: somente o menu ⋮.
+     * `inline` → alias de `hover` e `dropdown` → alias de `menu` (compatibilidade).
+     */
+    rowActionsVariant?: 'hover' | 'always' | 'menu' | 'inline' | 'dropdown';
     onNew?: () => void;
     newButtonLabel?: string;
     showNewButton?: boolean;
+    /** Quando informado (não vazio), o botão "Novo" vira um SplitButton com essas ações no menu. */
+    newButtonActions?: CustomAction[];
     customActions?: CustomAction[];
     /** @deprecated Use showActionBar={false} instead */
     hideActionBar?: boolean;
@@ -32,6 +38,12 @@ export interface CrudTableProps<T extends BaseEntity & {
     searchPlaceholder?: string;
     bulkActions?: BulkAction<T>[];
     onBulkDelete?: () => void;
+    /**
+     * Barra de seleção no topo (padrão Google Drive): ao selecionar linhas, as
+     * ações em lote sobem do menu de contexto para uma barra com ícones.
+     * Default: `true` quando `enableBulkActions`.
+     */
+    showSelectionToolbar?: boolean;
     filters?: React.ReactNode;
     viewMode?: ViewMode;
     onViewModeChange?: (mode: ViewMode) => void;
@@ -58,11 +70,30 @@ export interface CrudTableProps<T extends BaseEntity & {
     hideActionsColumn?: boolean;
     /** Modo somente leitura: oculta ações de linha e desabilita menu de contexto. */
     readOnly?: boolean;
+    /**
+     * Convenção única de ações condicionais por linha, aplicada de forma
+     * idêntica aos ícones (hover/always), ao menu ⋮ e ao menu de contexto:
+     * - `canEdit/canDelete/canToggleStatus: false` → **oculta** a ação;
+     * - `editDisabled/deleteDisabled/toggleStatusDisabled: true` → mantém a ação
+     *   **visível mas bloqueada**, sempre no menu, com tooltip do respectivo
+     *   `*DisabledReason`.
+     *
+     * Em ações customizadas use `show: false`/`hidden: true` (ocultar) e
+     * `disabled` + `disabledReason` (bloquear).
+     *
+     * @example
+     * rowActionsState={(item) => ({
+     *   canDelete: !item.is_system,
+     *   editDisabled: !item.is_actived,
+     *   editDisabledReason: 'Reative o registro para editar',
+     * })}
+     */
+    rowActionsState?: (item: T) => RowActionsState;
 }
 /**
  * Componente `CrudTable` da lib.
  * @example
  * <CrudTable />
  */
-export declare const CrudTable: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, enableBulkActions, rowActionsVariant, onNew, newButtonLabel, showNewButton, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, viewMode, onViewModeChange, showViewToggle, enableColumnResize, resizeStorageKey, enableColumnManager, columnManagerStorageKey, defaultHiddenColumns, enableGrouping, enableExpandableRows, renderExpandedContent, expandedRowIds: controlledExpandedIds, onToggleExpand: controlledToggleExpand, defaultExpandAll, hideActionsColumn, readOnly, }: CrudTableProps<T>) => React.JSX.Element;
+export declare const CrudTable: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, enableBulkActions, showSelectionToolbar, rowActionsVariant, onNew, newButtonLabel, showNewButton, newButtonActions, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, viewMode, onViewModeChange, showViewToggle, enableColumnResize, resizeStorageKey, enableColumnManager, columnManagerStorageKey, defaultHiddenColumns, enableGrouping, enableExpandableRows, renderExpandedContent, expandedRowIds: controlledExpandedIds, onToggleExpand: controlledToggleExpand, defaultExpandAll, hideActionsColumn, readOnly, rowActionsState, }: CrudTableProps<T>) => React.JSX.Element;
 export default CrudTable;

package/dist/crud/components/InlineRowActions.d.ts

@@ -1,15 +1,19 @@
 import React from 'react';
+import type { RowActionInput } from '../actions/useRowActions';
 interface InlineRowActionsProps {
     onEdit?: () => void;
     onDelete?: () => void;
     canDelete?: boolean;
     onToggleStatus?: () => void;
     isActive?: boolean;
-    customActions?: Array<{
-        icon: any;
-        label: string;
-        onClick: () => void;
-    }>;
+    customActions?: RowActionInput[];
 }
+/**
+ * Ações de linha em ícones sempre visíveis + menu ⋮ para o excedente.
+ *
+ * Wrapper fino sobre {@link RowActions} (`variant="always"`) — mantido para
+ * compatibilidade. O controle de hover é responsabilidade da linha (classe `group`),
+ * então prefira `RowActions` diretamente para o padrão hover.
+ */
 export declare const InlineRowActions: React.FC<InlineRowActionsProps>;
 export {};

package/dist/crud/components/KanbanActionBar.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+import { type CrudActionBarProps } from './CrudActionBar';
+import type { BaseEntity } from '../../types';
+/** Aparência do quadro: blocos (colunas Kanban) ou lista de cards horizontais. */
+/**
+ * Tipo `KanbanLayout` exportado pela lib.
+ * @example
+ * const value: KanbanLayout = 'board';
+ */
+export type KanbanLayout = 'board' | 'list';
+/**
+ * Tipo `KanbanFilterOption` exportado pela lib.
+ * @example
+ * const value: KanbanFilterOption = { value: 'alta', label: 'Alta' };
+ */
+export interface KanbanFilterOption {
+    value: string;
+    label: string;
+}
+/**
+ * Configuração declarativa de um filtro do grid do Kanban.
+ * @example
+ * const value: KanbanFilterConfig = {} as KanbanFilterConfig;
+ */
+export interface KanbanFilterConfig {
+    /** Identificador único do filtro. */
+    id: string;
+    /** Rótulo curto (uma palavra de preferência). */
+    label: string;
+    /** Valor atual — use `allValue` (default `'all'`) para "todos". */
+    value: string;
+    /** Opções disponíveis (sem a opção "todos"). */
+    options: KanbanFilterOption[];
+    onChange: (value: string) => void;
+    /** Valor sentinela de "todos". Default: `'all'`. */
+    allValue?: string;
+    /** Rótulo da opção "todos". Default: `Todos` + label. */
+    allLabel?: string;
+    /** Largura do trigger. Default: `'10.5rem'`. */
+    width?: string;
+}
+/**
+ * Tipo `KanbanActionBarProps` exportado pela lib.
+ * @example
+ * const value: KanbanActionBarProps = {} as KanbanActionBarProps;
+ */
+export interface KanbanActionBarProps<T extends BaseEntity = BaseEntity> extends Omit<CrudActionBarProps<T>, 'filters' | 'viewMode' | 'onViewModeChange' | 'showViewToggle' | 'availableViewModes'> {
+    /** Filtros declarativos do grid do quadro. */
+    filters?: KanbanFilterConfig[];
+    /** Slot para filtros avançados (datas, popovers, etc). */
+    extraFilters?: React.ReactNode;
+    /** Chamado ao limpar todos os filtros (o botão só aparece se informado). */
+    onClearFilters?: () => void;
+    /** Aparência atual do quadro. */
+    layout?: KanbanLayout;
+    onLayoutChange?: (layout: KanbanLayout) => void;
+    /** Exibe o toggle de aparência. Default: `true`. */
+    showLayoutToggle?: boolean;
+}
+declare function KanbanActionBarComponent<T extends BaseEntity = BaseEntity>({ filters, extraFilters, onClearFilters, layout, onLayoutChange, showLayoutToggle, newButtonLabel, searchPlaceholder, showSearch, ...rest }: KanbanActionBarProps<T>): React.JSX.Element;
+/**
+ * Componente `KanbanActionBar` da lib — action bar canônica de quadros Kanban.
+ * @example
+ * <KanbanActionBar layout={layout} onLayoutChange={setLayout} filters={[...]} />
+ */
+export declare const KanbanActionBar: typeof KanbanActionBarComponent;
+export default KanbanActionBar;

package/dist/crud/components/RowActions.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { type UseRowActionsOptions } from '../actions/useRowActions';
+export type RowActionsVariant = 'hover' | 'always' | 'menu';
+export interface RowActionsProps extends UseRowActionsOptions {
+    /**
+     * - `hover` (padrão): ícones rápidos aparecem no hover da linha + menu ⋮;
+     * - `always`: ícones rápidos sempre visíveis + menu ⋮;
+     * - `menu`: nenhum ícone solto, tudo no menu ⋮.
+     */
+    variant?: RowActionsVariant;
+    className?: string;
+}
+/**
+ * Componente padrão de ações de linha da lib.
+ *
+ * Regras de padronização (ver `useRowActions`):
+ * - no máximo 3 ícones de ação rápida;
+ * - demais ações no menu ⋮, agrupado com separadores a partir de 6 ações;
+ * - ações destrutivas nunca ficam como ícone rápido;
+ * - `disabled` mantém a ação visível no menu com tooltip do motivo.
+ *
+ * @example
+ * <RowActions
+ *   onEdit={() => edit(row)}
+ *   onDelete={() => remove(row)}
+ *   isActive={row.is_actived}
+ *   onToggleStatus={() => toggle(row)}
+ * />
+ */
+export declare const RowActions: React.FC<RowActionsProps>;

package/dist/crud/components/RowActionsMenuItems.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { ResolvedRowAction } from '../actions/useRowActions';
+export interface RowActionsMenuItemsProps {
+    /** Grupos já resolvidos por `useRowActions().menuGroups`. */
+    groups: Array<{
+        group: string;
+        items: ResolvedRowAction[];
+    }>;
+    /** Quando `false`, renderiza tudo numa lista contínua sem separadores. */
+    grouped?: boolean;
+    renderAs?: 'dropdown' | 'context';
+}
+/**
+ * Renderiza itens de menu de ações de linha, com separadores automáticos entre
+ * grupos quando o menu for grande (>= 6 ações), submenus com seta para ações
+ * aninhadas e atalhos de teclado alinhados à direita. Compartilhado entre o
+ * dropdown ⋮ e o menu de contexto (clique direito) para garantir paridade visual.
+ */
+export declare const RowActionsMenuItems: React.FC<RowActionsMenuItemsProps>;

package/dist/crud/components/RowContextMenu.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { type UseRowActionsOptions } from '../actions/useRowActions';
+export interface RowContextMenuProps extends UseRowActionsOptions {
+    children: React.ReactNode;
+    /** Quando `false`, renderiza apenas o conteúdo sem menu de contexto. */
+    enabled?: boolean;
+    className?: string;
+}
+/**
+ * Menu de contexto (clique direito) padrão de linhas/cards de CRUD.
+ *
+ * Reutiliza exatamente a mesma resolução de ações do `RowActions`
+ * (`useRowActions`): ordem canônica dos grupos, rótulos, ícones, variante
+ * `danger` e agrupamento com separadores a partir de 6 ações.
+ *
+ * @example
+ * <RowContextMenu onEdit={() => edit(row)} onDelete={() => remove(row)}>
+ *   <TableRow>...</TableRow>
+ * </RowContextMenu>
+ */
+export declare const RowContextMenu: React.FC<RowContextMenuProps>;

package/dist/crud/components/SelectionToolbar.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { BaseEntity, BulkAction } from '../../types';
+/** Quantidade máxima de ações exibidas como ícone direto na barra. */
+export declare const MAX_TOOLBAR_ACTIONS = 5;
+export interface SelectionToolbarProps<T extends BaseEntity = BaseEntity> {
+    /** Itens atualmente selecionados. */
+    selectedItems: T[];
+    /** Quantidade selecionada (usada quando `selectedItems` não está disponível). */
+    selectedCount?: number;
+    /** Ações em lote — as primeiras viram ícones, o resto vai para o menu ⋮. */
+    actions?: BulkAction<T>[];
+    /** Exclusão em lote (fallback quando não há `actions`). */
+    onBulkDelete?: () => void;
+    /** Limpa a seleção (botão X à esquerda). */
+    onClearSelection?: () => void;
+    /** Limite de ícones diretos (default {@link MAX_TOOLBAR_ACTIONS}). */
+    maxVisibleActions?: number;
+    className?: string;
+}
+declare function SelectionToolbarComponent<T extends BaseEntity = BaseEntity>({ selectedItems, selectedCount, actions, onBulkDelete, onClearSelection, maxVisibleActions, className, }: SelectionToolbarProps<T>): React.JSX.Element;
+/**
+ * Barra de seleção em lote exibida no topo da tabela.
+ * @example
+ * <SelectionToolbar selectedItems={selected} actions={bulkActions} onClearSelection={clear} />
+ */
+export declare const SelectionToolbar: typeof SelectionToolbarComponent;
+export default SelectionToolbar;

package/dist/crud/components/TableRowActions.d.ts

@@ -1,19 +1,22 @@
-interface TableRowActionsProps {
+import React from 'react';
+import type { RowActionInput, RowActionsState } from '../actions/useRowActions';
+interface TableRowActionsProps extends RowActionsState {
     onEdit?: () => void;
     onDelete?: () => void;
     canDelete?: boolean;
     onToggleStatus?: () => void;
     isActive?: boolean;
-    customActions?: Array<{
-        icon: any;
-        label: string;
-        onClick: () => void;
-    }>;
+    customActions?: RowActionInput[];
 }
 /**
- * Componente `TableRowActions` da lib.
+ * Menu de ações de linha somente-⋮.
+ *
+ * Wrapper fino sobre {@link RowActions} (`variant="menu"`) — mantido para
+ * compatibilidade. Em novas telas prefira `RowActions`, que já entrega ícones
+ * rápidos no hover + menu ⋮ conforme o padrão do DS.
+ *
  * @example
- * <TableRowActions />
+ * <TableRowActions onEdit={() => edit(row)} onDelete={() => remove(row)} />
  */
 export declare const TableRowActions: React.FC<TableRowActionsProps>;
 export {};

package/dist/crud/createCrudPage.d.ts

@@ -51,9 +51,6 @@ interface SimpleCrudPageConfig<T extends CrudEntity> {
     defaultHiddenColumns?: string[];
     /** Modo somente leitura: oculta ações e impede edição/exclusão. */
     readOnly?: boolean;
-    /** Exibir ação "Excluir" na linha e no dialog de confirmação (default: true). Use `false`
-     * quando a entidade não suporta exclusão de verdade (ex.: só "ignorar"/soft actions). */
-    showDeleteAction?: boolean;
 }
 interface CrudPageGeneratorConfig<T extends CrudEntity> {
     manager: any;

package/dist/crud/createSimpleService.d.ts

@@ -60,7 +60,6 @@ export declare function createSimpleService<T extends {
         searchTerm: string;
         sortField: string;
         sortDirection: "desc" | "asc";
-        hasStoredSort: boolean;
         currentPage: number;
         itemsPerPage: number;
         queryKey: string;
@@ -70,7 +69,6 @@ export declare function createSimpleService<T extends {
         save: (data: any, transform?: (data: any) => any) => void;
         handleSearch: (search: string) => void;
         handleSort: (field: string) => void;
-        setSort: (field: string, direction: "asc" | "desc") => void;
         handlePageChange: (newPage: number) => void;
         handleItemsPerPageChange: (newLimit: number) => void;
         clearFilters: () => void;

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

@@ -3,12 +3,23 @@ export interface UseColumnDragReorderOptions {
     enabled?: boolean;
     onReorder: (fromIndex: number, toIndex: number) => void;
 }
+export type ColumnDropSide = 'before' | 'after';
 export interface UseColumnDragReorderReturn {
     dragFromIndex: number | null;
     dragOverIndex: number | null;
+    /** Lado da coluna alvo onde o indicador de drop deve aparecer. */
+    dropSide: ColumnDropSide;
+    /** Retângulo do placeholder calculado no contêiner rolável da tabela. */
+    dropIndicator: ColumnDropIndicator | null;
     isDragging: boolean;
+    /**
+     * Classes utilitárias para animar o cabeçalho durante o drag
+     * (fonte única de verdade para CrudTable e o primitive Table).
+     */
+    getDragClassNames: (index: number) => string;
     getDragProps: (index: number, columnKey?: string) => {
         draggable: boolean;
+        'aria-grabbed'?: boolean;
         onDragStart: (e: React.DragEvent) => void;
         onDragOver: (e: React.DragEvent) => void;
         onDragEnter: (e: React.DragEvent) => void;
@@ -16,4 +27,11 @@ export interface UseColumnDragReorderReturn {
         onDragEnd: () => void;
     };
 }
+export interface ColumnDropIndicator {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    side: ColumnDropSide;
+}
 export declare function useColumnDragReorder({ enabled, onReorder, }: UseColumnDragReorderOptions): UseColumnDragReorderReturn;

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

@@ -37,8 +37,14 @@ export interface UseColumnManagerReturn<T> {
     toggleColumn: (key: string) => void;
     /** Show all columns */
     showAllColumns: () => void;
-    /** Reset columns to default order and visibility */
+    /** Hide all hideable columns */
+    hideAllColumns: () => void;
+    /** Reset columns to the user's saved default (or the initial default) */
     resetColumns: () => void;
+    /** Save current visibility/order as the user's default preset */
+    saveAsDefault: () => void;
+    /** Whether the user has a saved default preset */
+    hasCustomDefault: boolean;
     /** Current column order (keys) */
     columnOrder: string[];
     /** Reorder columns */

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

@@ -4,7 +4,7 @@
  * **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 e paginação via URL params; ordenação fica só no navegador (localStorage), não polui a querystring
+ * - ✅ 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
@@ -128,8 +128,6 @@ export declare function useCrud<T extends {
     searchTerm: string;
     sortField: string;
     sortDirection: "desc" | "asc";
-    /** `true` se a ordenação já veio de uma escolha salva no navegador (não do default do config/entidade). */
-    hasStoredSort: boolean;
     currentPage: number;
     itemsPerPage: number;
     queryKey: string;
@@ -139,8 +137,6 @@ export declare function useCrud<T extends {
     save: (data: any, transform?: (data: any) => any) => void;
     handleSearch: (search: string) => void;
     handleSort: (field: string) => void;
-    /** Define a ordenação diretamente (sem alternar asc/desc). Usado para aplicar `defaultSort` inicial. */
-    setSort: (field: string, direction: "asc" | "desc") => void;
     handlePageChange: (newPage: number) => void;
     handleItemsPerPageChange: (newLimit: number) => void;
     clearFilters: () => void;

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

@@ -1,70 +1,26 @@
 /**
  * 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.
+ * Menu de ações reutilizável fora do contexto de tabela. Desde a padronização do DS,
+ * delega toda a resolução de ações para `useRowActions` e a renderização para
+ * `RowActions`, garantindo paridade de rótulos, ordem, ícones e agrupamento com o
+ * `CrudTable`.
  *
- * @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"
- * />
- * ```
+ * Para tabelas inteiras, prefira a prop `rowActions`/`RowActions` do `CrudTable`.
  */
 import React from 'react';
 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}
- * />
+ * // Dropdown padrão (⋮) com Editar + Excluir
+ * <ActionMenu onEdit={() => openEdit(row)} onDelete={() => confirmDelete(row.id)} />
  *
  * @example
- * // Inline compacto com ações customizadas + bloqueio condicional
+ * // Ícones sempre visíveis (inline) com ações customizadas
  * <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}
+ *   customActions={[{ label: 'Duplicar', icon: Copy, onClick: () => duplicate(row) }]}
  * />
  */
-export declare function ActionMenu({ onEdit, onDelete, onToggleStatus, isActive, canEdit, canDelete, customActions, renderAs, variant }: ActionMenuProps): React.JSX.Element;
+export declare function ActionMenu({ onEdit, onDelete, onToggleStatus, isActive, canEdit, canDelete, customActions, renderAs, }: ActionMenuProps): React.JSX.Element;