forlogic-core 3.0.11 → 4.0.0

package/dist/components/ui/status-badge.d.ts

@@ -1,38 +1,73 @@
 import React from 'react';
-import { type LucideIcon } from 'lucide-react';
+import { type Icon as PhosphorIcon } from '@phosphor-icons/react';
+/**
+ * Tom semântico canônico das tags do DS.
+ * Sempre resolvido por tokens (`--control-*`, `--primary`, `--muted`),
+ * garantindo paridade em light/dark e nas 4 essências de marca.
+ */
+export type BadgeTone = 'neutral' | 'brand' | 'info' | 'success' | 'warning' | 'danger';
+export type BadgeSize = 'sm' | 'md' | 'lg';
+export type BadgeAppearance = 'filled' | 'outline' | 'ghost' | 'solid';
 export interface StatusBadgeProps {
     /** Texto exibido no badge */
-    label: string;
-    /** Cor semântica (hex) — gera fundo pastel automaticamente */
-    color: string;
-    /** Ícone Lucide exibido à esquerda do texto */
-    icon?: LucideIcon;
+    label: React.ReactNode;
+    /** Tom semântico (recomendado) — resolvido por tokens do tema */
+    tone?: BadgeTone;
+    /**
+     * Cor semântica (hex) — modo legado. Gera fundo pastel automaticamente.
+     * Prefira `tone` para manter paridade entre temas.
+     * @deprecated Use `tone`.
+     */
+    color?: string;
+    /** Ícone Phosphor exibido à esquerda do texto */
+    icon?: PhosphorIcon;
     /** Exibe o ícone (default: true quando icon fornecido) */
     showIcon?: boolean;
+    /** Ponto indicador antes do texto (padrão de status em tabelas) */
+    dot?: boolean;
     /** Tamanho do badge */
-    size?: 'sm' | 'md' | 'lg';
-    /** Variante visual */
-    variant?: 'filled' | 'outline' | 'ghost';
-    /** Override do fundo pastel automático */
+    size?: BadgeSize;
+    /** Intensidade visual */
+    variant?: BadgeAppearance;
+    /** Override do fundo pastel automático (modo legado com `color`) */
     backgroundColor?: string;
+    /** Torna a tag removível (chip de filtro) */
+    onRemove?: () => void;
+    /** Rótulo acessível do botão de remoção */
+    removeLabel?: string;
     /** Classes adicionais */
     className?: string;
 }
 export interface StatusConfig {
     label: string;
-    color: string;
-    icon?: LucideIcon;
+    color?: string;
+    tone?: BadgeTone;
+    icon?: PhosphorIcon;
     tooltipText?: string;
 }
 /**
- * Badge de status genérico e reutilizável.
- * Aceita cor semântica e gera fundo pastel automaticamente.
- * Pode ser usado em qualquer CRUD, tabela ou card.
+ * Matriz canônica tom × intensidade. Todas as combinações usam apenas
+ * tokens semânticos — nenhuma cor literal.
+ */
+export declare const BADGE_TONE_CLASSES: Record<BadgeTone, Record<BadgeAppearance, string>>;
+/** Geometria única de todas as tags do DS (Badge e StatusBadge). */
+export declare const BADGE_BASE_CLASSES = "inline-flex items-center rounded-md border font-medium leading-none whitespace-nowrap align-middle transition-colors";
+/**
+ * Tag canônica de status do Design System.
+ *
+ * Padrão único para qualquer estado de dado (workflow, aprovação, prazo):
+ * geometria `rounded-md`, três tamanhos, quatro intensidades e seis tons
+ * semânticos resolvidos por tokens — idênticos em light/dark e em todas as
+ * essências de marca.
  *
  * @example
- * StatusBadge();
+ * ```tsx
+ * <StatusBadge tone="success" label="Vigente" dot />
+ * <StatusBadge tone="warning" label="Em revisão" icon={Clock} />
+ * <StatusBadge tone="brand" label="Qualidade" onRemove={() => remove()} />
+ * ```
  */
-export declare function StatusBadge({ label, color, icon: Icon, showIcon, size, variant, backgroundColor, className, }: StatusBadgeProps): React.JSX.Element;
+export declare function StatusBadge({ label, tone, color, icon: Icon, showIcon, dot, size, variant, backgroundColor, onRemove, removeLabel, className, }: StatusBadgeProps): React.JSX.Element;
 /**
  * Cria um lookup type-safe de configuração de status.
  * Útil para mapear enums de domínio para props do StatusBadge.
@@ -40,14 +75,9 @@ export declare function StatusBadge({ label, color, icon: Icon, showIcon, size,
  * @example
  * ```ts
  * const getOrderStatus = createStatusConfig({
- *   pending: { label: 'Pendente', color: '#8B7355', icon: Clock },
- *   approved: { label: 'Aprovado', color: '#3D7A40', icon: CheckCircle2 },
- *   rejected: { label: 'Rejeitado', color: '#B44A4A', icon: X },
+ *   pending: { label: 'Pendente', tone: 'warning', icon: Clock },
+ *   approved: { label: 'Aprovado', tone: 'success', icon: CheckCircle },
  * });
- *
- * // Uso:
- * const config = getOrderStatus('pending');
- * <StatusBadge {...config} />
  * ```
  */
 export declare function createStatusConfig<T extends string | number>(statuses: Record<T, StatusConfig>): (status: T) => StatusConfig;

package/dist/components/ui/status-bar.d.ts

@@ -0,0 +1,43 @@
+import * as React from "react";
+/**
+ * StatusBar Component (v3)
+ *
+ * Átomo universal de barra de status/progresso do Design System.
+ * Indica o andamento de um processo (steps, wizard, upload, sync) com
+ * preenchimento grosso e pontas totalmente arredondadas.
+ *
+ * Diferença para `Progress`: o `StatusBar` é pensado para contextos de
+ * navegação/status (wizards, etapas), com trilho em cor terciária sempre
+ * visível (mostra o tamanho total da barra).
+ *
+ * @example
+ * ```tsx
+ * <StatusBar value={40} aria-label="Etapas" />
+ * <StatusBar value={75} size="sm" />
+ * ```
+ *
+ * ## Características
+ * - Valor de 0 a 100 (clamp automático)
+ * - Pontas arredondadas (`rounded-full`) em trilho e preenchimento
+ * - Trilho com cor terciária (`--button-tertiary-bg`) sempre visível —
+ *   evidencia o tamanho total da barra e o quanto já foi preenchido
+ * - Sombreamento interno sutil no trilho e no preenchimento
+ * - Animação suave e orgânica de transição de largura
+ * - Tamanhos `sm` (h-1.5), `md` (h-2.5), `lg` (h-3.5)
+ * - Acessibilidade completa (`role="progressbar"` + aria-valuenow)
+ */
+export interface StatusBarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Valor de 0 a 100. Valores fora do intervalo são limitados automaticamente. */
+    value: number;
+    /**
+     * @deprecated O trilho terciário agora é sempre exibido (padrão v3).
+     * Mantido apenas para retrocompatibilidade — não tem efeito.
+     */
+    showTrack?: boolean;
+    /** Espessura da barra. Default: `md`. */
+    size?: "sm" | "md" | "lg";
+    /** Classes extras aplicadas ao preenchimento. */
+    indicatorClassName?: string;
+}
+declare const StatusBar: React.ForwardRefExoticComponent<StatusBarProps & React.RefAttributes<HTMLDivElement>>;
+export { StatusBar };

package/dist/components/ui/table-dialog.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { type Icon as PhosphorIcon } from '@phosphor-icons/react';
+import { type DialogTone } from './dialog-signal';
+export interface TableDialogColumn<T> {
+    /** Cabeçalho — preferir uma palavra. */
+    header: React.ReactNode;
+    /** Renderiza a célula da linha. */
+    cell: (row: T, index: number) => React.ReactNode;
+    className?: string;
+}
+export interface TableDialogProps<T> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    tone?: DialogTone;
+    icon?: PhosphorIcon;
+    columns: Array<TableDialogColumn<T>>;
+    rows: T[];
+    rowKey: (row: T, index: number) => string;
+    /** Estado vazio quando `rows` está vazio. */
+    emptyState?: React.ReactNode;
+    /** Conteúdo à esquerda do footer (contadores, filtros). */
+    footerLeft?: React.ReactNode;
+    closeText?: string;
+    /** Ação primária opcional (ex.: "Adicionar selecionados"). */
+    primaryAction?: {
+        label: string;
+        onClick: () => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+}
+/**
+ * TableDialog — dialog de leitura com tabela densa e cabeçalho fixo.
+ *
+ * Usa a mesma densidade das tabelas do sistema (header `h-9`, células `py-2`)
+ * e o `DialogBody` como única área de rolagem.
+ *
+ * @example
+ * <TableDialog
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   title="Participantes vinculados"
+ *   columns={[{ header: 'Nome', cell: (r) => r.name }]}
+ *   rows={rows}
+ *   rowKey={(r) => r.id}
+ * />
+ */
+export declare function TableDialog<T>({ open, onOpenChange, title, description, tone, icon, columns, rows, rowKey, emptyState, footerLeft, closeText, primaryAction, }: TableDialogProps<T>): React.JSX.Element;
+export default TableDialog;

package/dist/components/ui/table.d.ts

@@ -87,7 +87,7 @@ declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTM
  */
 declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
 /**
- * Célula de dado (`<td>`). Padding `py-2 px-4` e `overflow-hidden`
+ * Célula de dado (`<td>`). Altura fixa `h-10`, padding `py-1.5 px-4`, `leading-5` e `overflow-hidden`
  * (combinar com `TruncatedCell` para texto longo).
  *
  * @example

package/dist/components/ui/tabs.d.ts

@@ -30,37 +30,45 @@ import * as TabsPrimitive from "@radix-ui/react-tabs";
  * ```
  */
 declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+type TabsVariant = "default" | "pill";
+type TabsSize = "sm" | "md" | "lg";
+type TabsTone = "neutral" | "accent";
 /**
- * Container horizontal dos triggers de aba. Aparência de "pill group" com fundo `muted`.
- *
- * @example
- * ```tsx
- * <TabsList>
- *   <TabsTrigger value="a">A</TabsTrigger>
- *   <TabsTrigger value="b">B</TabsTrigger>
- * </TabsList>
- * ```
+ * Container horizontal dos triggers de aba. Estilo padrão (v2) com trilho
+ * sombreado e indicador deslizante. Use `variant="pill"` para a forma
+ * secundária em pílula.
  */
-declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-/**
- * Botão de uma aba. O `value` deve corresponder a um `TabsContent` irmão.
- *
- * @example
- * ```tsx
- * <TabsTrigger value="settings">Configurações</TabsTrigger>
- * ```
- */
-declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    /** Forma do trilho/indicador. `default` = raio padrão do DS, `pill` = pílula. */
+    variant?: TabsVariant;
+    /** Tamanho do trilho e dos triggers. */
+    size?: TabsSize;
+    /** Cor do indicador: neutro (tertiary) ou colorido (primary). */
+    tone?: TabsTone;
+} & React.RefAttributes<HTMLDivElement>>;
+/** Botão de uma aba. Herda a `variant` da lista. */
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    variant?: TabsVariant;
+    size?: TabsSize;
+    tone?: TabsTone;
+} & React.RefAttributes<HTMLButtonElement>>;
 /**
  * Conteúdo associado a um `TabsTrigger`. O `value` deve casar com o trigger.
- * Renderizado apenas quando a aba está ativa (forceMount=false por padrão).
- *
- * @example
- * ```tsx
- * <TabsContent value="settings">
- *   <SettingsForm />
- * </TabsContent>
- * ```
  */
 declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { Tabs, TabsList, TabsTrigger, TabsContent };
+declare const NavTabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const NavTabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    /** Forma do trilho/indicador. `default` = raio padrão do DS, `pill` = pílula. */
+    variant?: TabsVariant;
+    /** Tamanho do trilho e dos triggers. */
+    size?: TabsSize;
+    /** Cor do indicador: neutro (tertiary) ou colorido (primary). */
+    tone?: TabsTone;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const NavTabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    variant?: TabsVariant;
+    size?: TabsSize;
+    tone?: TabsTone;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent, NavTabs, NavTabsList, NavTabsTrigger };
+export type { TabsVariant, TabsSize, TabsTone };

package/dist/components/ui/textarea.d.ts

@@ -8,6 +8,8 @@ import * as React from "react";
  * ```
  */
 export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Estado de carregamento padronizado (aria-busy + tokens `control-loading-*`). */
+    loading?: boolean;
     /**
      * Quando `true` e `maxLength` for definido, exibe contador `N / max`
      * abaixo do textarea (alinhado à direita).

package/dist/components/ui/toggle-group.d.ts

@@ -16,8 +16,8 @@ import { type VariantProps } from "class-variance-authority";
  * ```
  */
 declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: {
-    variant?: "outline" | "default";
-    size?: "default" | "sm" | "lg";
+    variant?: "default" | "outline";
+    size?: "sm" | "lg" | "default";
 } & import("class-variance-authority/types").ClassProp) => string>) & React.RefAttributes<HTMLDivElement>>;
 /**
  * Item individual de um `ToggleGroup`. Herda `variant`/`size` do grupo, mas
@@ -31,7 +31,7 @@ declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPri
  * ```
  */
 declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
-    variant?: "outline" | "default";
-    size?: "default" | "sm" | "lg";
+    variant?: "default" | "outline";
+    size?: "sm" | "lg" | "default";
 } & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
 export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -11,8 +11,8 @@ import { type VariantProps } from "class-variance-authority";
  * ```
  */
 declare const toggleVariants: (props?: {
-    variant?: "outline" | "default";
-    size?: "default" | "sm" | "lg";
+    variant?: "default" | "outline";
+    size?: "sm" | "lg" | "default";
 } & import("class-variance-authority/types").ClassProp) => string;
 /**
  * Botão alternável (on/off). Use para ações binárias como "Negrito", "Itálico"
@@ -27,7 +27,7 @@ declare const toggleVariants: (props?: {
  * ```
  */
 declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
-    variant?: "outline" | "default";
-    size?: "default" | "sm" | "lg";
+    variant?: "default" | "outline";
+    size?: "sm" | "lg" | "default";
 } & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
 export { Toggle, toggleVariants };

package/dist/components/ui/typography.d.ts

@@ -4,7 +4,7 @@
  * `H1`, `H2`, `H3`, `H4`, `P`, `Lead`, `Large`, `Small`, `Muted`, `InlineCode`, `Blockquote`, `List`.
  *
  * Use sempre que possível ao invés de aplicar classes Tailwind soltas em `<h1>`, `<p>`, etc.
- * Garante consistência com a fonte base Inter (13px) e a escala definida em `index.css`.
+ * Garante consistência com a fonte base Roobert Pro (13px) e a escala definida em `index.css`.
  *
  * @see `docs/design-system/foundation.md`
  */

package/dist/crud/actions/qualityActions.d.ts

@@ -0,0 +1,55 @@
+import type { RowActionInput } from './useRowActions';
+export interface QualityActionOptions {
+    onClick: () => void;
+    disabled?: boolean;
+    disabledReason?: string;
+    show?: boolean;
+}
+/** Duplicar registro (mantendo revisão/versão zerada). */
+export declare const duplicateAction: (o: QualityActionOptions) => RowActionInput;
+/** Copiar link permanente do registro (rastreabilidade em auditorias). */
+export declare const copyLinkAction: (o: QualityActionOptions) => RowActionInput;
+/** Exportar em formatos de evidência (submenu PDF/Excel/CSV). */
+export declare const exportAction: (handlers: {
+    onPdf?: () => void;
+    onExcel?: () => void;
+    onCsv?: () => void;
+}) => RowActionInput;
+/** Abrir trilha de auditoria / histórico de revisões. */
+export declare const auditTrailAction: (o: QualityActionOptions) => RowActionInput;
+/** Assinar eletronicamente (evidência com carimbo de tempo). */
+export declare const signAction: (o: QualityActionOptions) => RowActionInput;
+/** Enviar para fluxo de aprovação. */
+export declare const sendToApprovalAction: (o: QualityActionOptions) => RowActionInput;
+/** Aprovar diretamente (quando o usuário é aprovador). */
+export declare const approveAction: (o: QualityActionOptions) => RowActionInput;
+/** Vincular a um plano de ação (tratativa de não conformidade). */
+export declare const linkActionPlanAction: (o: QualityActionOptions) => RowActionInput;
+/** Notificar responsáveis por e-mail. */
+export declare const notifyAction: (o: QualityActionOptions) => RowActionInput;
+/** Atribuir responsável / equipe. */
+export declare const assignAction: (o: QualityActionOptions) => RowActionInput;
+/** Arquivar (obsoletar) preservando histórico — alternativa ao delete. */
+export declare const archiveAction: (o: QualityActionOptions) => RowActionInput;
+/**
+ * Catálogo completo, útil para descoberta em docs/autocomplete.
+ * @example
+ * customActions={[qualityActions.duplicate({ onClick: dup }), qualityActions.export({ onPdf })]}
+ */
+export declare const qualityActions: {
+    duplicate: (o: QualityActionOptions) => RowActionInput;
+    copyLink: (o: QualityActionOptions) => RowActionInput;
+    export: (handlers: {
+        onPdf?: () => void;
+        onExcel?: () => void;
+        onCsv?: () => void;
+    }) => RowActionInput;
+    auditTrail: (o: QualityActionOptions) => RowActionInput;
+    sign: (o: QualityActionOptions) => RowActionInput;
+    sendToApproval: (o: QualityActionOptions) => RowActionInput;
+    approve: (o: QualityActionOptions) => RowActionInput;
+    linkActionPlan: (o: QualityActionOptions) => RowActionInput;
+    notify: (o: QualityActionOptions) => RowActionInput;
+    assign: (o: QualityActionOptions) => RowActionInput;
+    archive: (o: QualityActionOptions) => RowActionInput;
+};

package/dist/crud/actions/useRowActions.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Fonte única de verdade para ações de linha (CrudTable, TableRowActions,
+ * InlineRowActions, ActionMenu e menus de contexto).
+ *
+ * Padrão acordado:
+ * - até {@link MAX_QUICK_ACTIONS} ações rápidas em ícones (visíveis no hover da linha);
+ * - o restante sempre no menu de contexto (⋮);
+ * - a partir de {@link GROUPED_MENU_THRESHOLD} ações, o menu passa a ser agrupado
+ *   com separadores (`primary` → `status` → `danger`).
+ */
+/** Máximo de ícones de ação rápida exibidos direto na linha. */
+export declare const MAX_QUICK_ACTIONS = 3;
+/** A partir deste total de ações, o menu ⋮ é renderizado agrupado com separadores. */
+export declare const GROUPED_MENU_THRESHOLD = 6;
+export type RowActionGroup = 'primary' | 'status' | 'danger';
+export interface RowActionInput {
+    label: string;
+    icon?: any;
+    onClick: () => void;
+    /** `destructive` mantido por compatibilidade; equivale a `variant: 'danger'`. */
+    destructive?: boolean;
+    variant?: 'default' | 'danger' | 'destructive';
+    /**
+     * Convenção de visibilidade: `show: false` (ou `hidden: true`) remove a ação
+     * de TODAS as superfícies (ícone rápido, menu ⋮ e menu de contexto).
+     */
+    show?: boolean;
+    /** Alias negativo de `show` — `hidden: true` equivale a `show: false`. */
+    hidden?: boolean;
+    /**
+     * Convenção de bloqueio: a ação continua visível, porém nunca como ícone
+     * rápido — vai para o menu, cinza e com tooltip de `disabledReason`.
+     */
+    disabled?: boolean;
+    disabledReason?: string;
+    /** Força (`true`) ou impede (`false`) a ação de aparecer como ícone rápido na linha. */
+    quick?: boolean;
+    group?: RowActionGroup;
+    /** Atalho de teclado exibido à direita no menu (ex.: `⌘C`, `Delete`). */
+    shortcut?: string;
+    /**
+     * Ações aninhadas: renderizam um submenu com seta (nunca como ícone rápido).
+     * Ex.: `Exportar` → `PDF`, `Excel`, `CSV`.
+     */
+    children?: RowActionInput[];
+}
+export interface ResolvedRowAction {
+    key: string;
+    label: string;
+    icon?: any;
+    onClick: () => void;
+    variant: 'default' | 'danger';
+    group: RowActionGroup;
+    disabled?: boolean;
+    disabledReason?: string;
+    quick: boolean;
+    shortcut?: string;
+    children?: ResolvedRowAction[];
+}
+/**
+ * Estado condicional de uma linha, aplicado igualmente ao hover (ícones) e aos
+ * menus (⋮ e clique direito).
+ *
+ * - `can*: false` → ação **oculta**;
+ * - `*Disabled: true` → ação **visível mas bloqueada**, sempre no menu, com
+ *   tooltip de `*DisabledReason`.
+ */
+export interface RowActionsState {
+    canEdit?: boolean;
+    canDelete?: boolean;
+    canToggleStatus?: boolean;
+    editDisabled?: boolean;
+    editDisabledReason?: string;
+    deleteDisabled?: boolean;
+    deleteDisabledReason?: string;
+    toggleStatusDisabled?: boolean;
+    toggleStatusDisabledReason?: string;
+}
+export interface UseRowActionsOptions extends RowActionsState {
+    onEdit?: () => void;
+    onDelete?: () => void;
+    onToggleStatus?: () => void;
+    isActive?: boolean;
+    customActions?: RowActionInput[];
+    /** Limite de ícones rápidos (default {@link MAX_QUICK_ACTIONS}). */
+    maxQuickActions?: number;
+}
+export interface UseRowActionsReturn {
+    /** Todas as ações resolvidas, na ordem canônica. */
+    actions: ResolvedRowAction[];
+    /** Ações exibidas como ícone na linha. */
+    quickActions: ResolvedRowAction[];
+    /** Ações exibidas no menu ⋮ (as que não couberam como ícone). */
+    menuActions: ResolvedRowAction[];
+    /** `true` quando o menu deve ser renderizado agrupado com separadores. */
+    isGroupedMenu: boolean;
+    /** Ações do menu já divididas por grupo, na ordem canônica. */
+    menuGroups: Array<{
+        group: RowActionGroup;
+        items: ResolvedRowAction[];
+    }>;
+    hasActions: boolean;
+}
+/**
+ * Resolve, ordena e classifica as ações de uma linha de tabela.
+ *
+ * @example
+ * const { quickActions, menuActions, isGroupedMenu } = useRowActions({
+ *   onEdit: () => edit(row),
+ *   onDelete: () => remove(row),
+ *   customActions: [{ label: 'Duplicar', icon: Copy, onClick: dup, quick: true }],
+ * });
+ */
+export declare function useRowActions({ onEdit, onDelete, onToggleStatus, isActive, canEdit, canDelete, canToggleStatus, editDisabled, editDisabledReason, deleteDisabled, deleteDisabledReason, toggleStatusDisabled, toggleStatusDisabledReason, customActions, maxQuickActions, }: UseRowActionsOptions): UseRowActionsReturn;

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

@@ -1,22 +1,19 @@
 import React from 'react';
+import { type RowActionInput } from '../actions/useRowActions';
 interface ActionMenuItemsProps {
     onEdit?: () => void;
     onDelete?: () => void;
     onToggleStatus?: () => void;
     isActive?: boolean;
     canDelete?: boolean;
-    customActions?: Array<{
-        icon: any;
-        label: string;
-        onClick: () => void;
-        destructive?: boolean;
-    }>;
+    customActions?: RowActionInput[];
     renderAs: 'dropdown' | 'context';
 }
 /**
- * Componente `ActionMenuItems` da lib.
- * @example
- * <ActionMenuItems />
+ * Itens de menu de ações de linha (dropdown ⋮ ou menu de contexto).
+ *
+ * Usa a mesma resolução de ações do `RowActions` (`useRowActions`), garantindo
+ * ordem, rótulos, ícones e agrupamento idênticos em todos os menus.
  */
 export declare const ActionMenuItems: React.FC<ActionMenuItemsProps>;
 export {};

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;