@rendra-ui/web 2.3.0 → 2.5.0

package/dist/types/components/app-shell/app-shell.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from 'react';
 import { type ShellLayout } from './layout';
-import type { NavGroup, ShellMenuItem, ShellNotificationsConfig, ShellUser } from './types';
+import type { NavGroup, ShellMenuItem, ShellNotificationsConfig, ShellUser, ShellUserMenuConfig, ShellWorkspacesConfig } from './types';
 export interface AppShellProps {
     /** Menu do sistema: sidebar, barra inferior e busca global. Único obrigatório. */
     navigation: NavGroup[];
@@ -18,6 +18,26 @@ export interface AppShellProps {
     quickActions?: ShellMenuItem[];
     /** Notificações do sino do header. Sem esta prop, o sino não aparece. */
     notifications?: ShellNotificationsConfig;
+    /**
+     * Quais submenus o menu do avatar mostra: `theme` (Tema), `template` (Template) e
+     * `layout` (Layout). Todos `true` por padrão; `{ theme: false }` esconde só o Tema.
+     * É o caminho para tirar essas escolhas do usuário (`userConfigurable` não faz isso).
+     */
+    userMenu?: ShellUserMenuConfig;
+    /**
+     * Seletor de espaço (empresa, unidade, workspace) no topo do menu do avatar, logo depois
+     * do usuário: um item de rádio por espaço, o de `activeId` marcado. `onSelect` recebe o
+     * `id` escolhido. Sem esta prop, o menu é o de sempre.
+     */
+    workspaces?: ShellWorkspacesConfig;
+    /**
+     * Logo do header no celular (abaixo de `md`): ocupa o lugar do título e da trilha. O título
+     * continua anunciado ao leitor de tela (só some do visual), o botão de voltar e o ícone de
+     * ajuda da tela ficam, e a trilha sai do header. A partir de `md` nada muda. O contêiner é
+     * `aria-hidden`: o logo é decorativo para o leitor, então o nó **não pode ser interativo**
+     * (um link ali dentro reprova `aria-hidden-focus` no axe).
+     */
+    headerLogo?: ReactNode;
     /**
      * Permite que o usuário troque o layout pelo menu do avatar (guardado no navegador).
      * Desligue em produção se o layout do projeto for fixo.
@@ -33,4 +53,4 @@ export interface AppShellProps {
  * Título da aba e meta description (SEO) não são responsabilidade do AppShell: o
  * boilerplate (src/app/app-layout.tsx) aplica isso com useRouteMeta, que lê @/config/seo.
  */
-export declare function AppShell({ navigation, layout: layoutProp, user, userMenuItems, onLogout, homeLabel, quickActions, notifications, userConfigurable, children, }: AppShellProps): import("react").JSX.Element;
+export declare function AppShell({ navigation, layout: layoutProp, user, userMenuItems, onLogout, homeLabel, quickActions, notifications, userMenu, workspaces, headerLogo, userConfigurable, children, }: AppShellProps): import("react").JSX.Element;

package/dist/types/components/app-shell/shell-context.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { ShellLayout } from './layout';
 import type { NavigationTarget } from './navigation-utils';
-import type { NavGroup, NavItem, ShellMenuItem, ShellNotificationsConfig, ShellUser } from './types';
+import type { NavGroup, NavItem, ShellMenuItem, ShellNotificationsConfig, ShellUser, ShellUserMenuConfig, ShellWorkspacesConfig } from './types';
 export interface ShellContextValue {
     /** Layout efetivo: padrão interno + prop `layout` do AppShell + escolha do usuário. */
     layout: ShellLayout;
@@ -43,6 +43,12 @@ export interface ShellContextValue {
     quickActions: ShellMenuItem[];
     /** Notificações do sino do header. Sem esta prop, o sino não aparece. */
     notifications?: ShellNotificationsConfig;
+    /** Submenus Tema, Template e Layout do menu do avatar. Sem esta prop, os três aparecem. */
+    userMenu?: ShellUserMenuConfig;
+    /** Seletor de espaço no topo do menu do avatar. Sem esta prop, não aparece. */
+    workspaces?: ShellWorkspacesConfig;
+    /** Logo que ocupa o lugar do título e da trilha no header, abaixo de `md`. */
+    headerLogo?: ReactNode;
 }
 export declare const ShellContext: import("react").Context<ShellContextValue | null>;
 export declare function useShell(): ShellContextValue;

package/dist/types/components/app-shell/types.d.ts

@@ -51,3 +51,26 @@ export interface ShellNotificationsConfig {
     onMarkAllRead?: () => void;
     onItemClick?: (id: string) => void;
 }
+/** Quais submenus o menu do avatar mostra. Cada um é `true` por padrão. */
+export interface ShellUserMenuConfig {
+    /** Submenu "Tema" (claro, escuro, automático). */
+    theme?: boolean;
+    /** Submenu "Template" (modelo e paleta de cores). */
+    template?: boolean;
+    /** Submenu "Layout" (posição e comportamento do menu). */
+    layout?: boolean;
+}
+/** Seletor de espaço (empresa, unidade, workspace) no topo do menu do avatar. */
+export interface ShellWorkspacesConfig {
+    /** Espaços disponíveis. Lista vazia não desenha o bloco. */
+    items: {
+        id: string;
+        label: string;
+    }[];
+    /** `id` do espaço atual (o item marcado). */
+    activeId: string;
+    /** Chamado com o `id` do espaço escolhido. A troca em si é de quem monta a aplicação. */
+    onSelect: (id: string) => void;
+    /** Título do bloco no menu. Padrão: "Espaço". */
+    label?: string;
+}

package/dist/types/components/layout/page-header.d.ts

@@ -26,8 +26,24 @@ export interface PageHeaderProps {
      * dividindo a largura; no desktop ficam à direita, com largura automática.
      */
     actions?: ReactNode;
+    /**
+     * Título discreto no topo do corpo quando o cabeçalho do shell esconde o título (no celular,
+     * com `headerLogo`): `text-base` abaixo de `md` e só de leitor de tela a partir dele.
+     * `showTitle` vence. Padrão: `false`.
+     */
+    bodyTitle?: boolean;
+    /**
+     * `reserve` (padrão): o bloco do título ocupa lugar mesmo quando o título é só de leitor de
+     * tela (o vão de 16 px acima das ações no celular). `none`: sem título visível e sem
+     * `description`, o bloco não é desenhado e o vão some; o `h1` segue no DOM para o leitor.
+     */
+    titleSpace?: 'reserve' | 'none';
     /** Conteúdo abaixo, como abas ou metadados. */
     children?: ReactNode;
+    /**
+     * Classes extras, que vencem as do componente. Para zerar a margem negativa de baixo (que
+     * aproxima o cabeçalho do conteúdo) use `className="mb-0 md:mb-0"`.
+     */
     className?: string;
 }
 /**
@@ -35,4 +51,4 @@ export interface PageHeaderProps {
  * O título fica no header (com a trilha); aqui ele só é lido por leitores de tela,
  * para que cada página tenha um único título principal (h1).
  */
-export declare function PageHeader({ title, showTitle, description, help, breadcrumb, actions, children, className, }: PageHeaderProps): import("react").JSX.Element;
+export declare function PageHeader({ title, showTitle, description, help, breadcrumb, actions, bodyTitle, titleSpace, children, className, }: PageHeaderProps): import("react").JSX.Element;

package/dist/types/components/rendra-provider.d.ts

@@ -1,4 +1,5 @@
 import { type ComponentType, type ReactNode } from 'react';
+import { type MotionMode } from '../lib/motion/motion-context';
 /**
  * Link com a mesma interface do `<a>`/`Link`: recebe `to`, `className`, `children`,
  * `aria-*`, `onClick` e repassa o resto.
@@ -28,13 +29,18 @@ export interface RendraProviderProps {
     goBack: () => void;
     /** Trilha da rota atual (ex.: via `useMatches` e `handle.crumb`). Opcional. */
     useBreadcrumbs?: () => RendraBreadcrumbItem[];
+    /**
+     * Animações dos componentes. `off` (padrão): sem nenhuma animação do Motion, a árvore e o
+     * comportamento de sempre. `on`: entradas, saídas e layout animados pelo Motion.
+     */
+    motion?: MotionMode;
 }
 /**
  * Única peça que sabe como navegar (`react-router`, outro roteador, ou nenhum).
  * Sem `RendraProvider` na árvore, os hooks abaixo caem para um comportamento simples,
  * baseado só em `window.location`/`history`, e os componentes continuam funcionando.
  */
-export declare function RendraProvider({ children, linkComponent, useCurrentPath: useCurrentPathProp, navigate, goBack, useBreadcrumbs, }: RendraProviderProps): import("react").JSX.Element;
+export declare function RendraProvider({ children, linkComponent, useCurrentPath: useCurrentPathProp, navigate, goBack, useBreadcrumbs, motion, }: RendraProviderProps): import("react").JSX.Element;
 /** Componente de link do provider ativo (ou `<a href>`, sem provider). */
 export declare function useRendraLink(): ComponentType<RendraLinkProps>;
 /** Caminho atual (ex.: `/clientes/novo`), do provider ativo ou de `window.location`. */

package/dist/types/components/rendra-router-bridge.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode } from 'react';
+import type { MotionMode } from '../lib/motion/motion-context';
 /**
  * Metadados de rota lidos pela trilha: handle: { crumb: 'Clientes' }. Convenção do
  * react-router (`handle`), que não existe em outros roteadores; por isso fica aqui, na
@@ -13,6 +14,7 @@ export interface RouteHandle {
  * componentes de `src/components/ui` e o `AppShell` não importam `react-router` diretamente.
  * Sem `children`, renderiza `<Outlet />`, para ser usado como elemento raiz das rotas.
  */
-export declare function RendraRouterBridge({ children }?: {
+export declare function RendraRouterBridge({ children, motion, }?: {
     children?: ReactNode;
+    motion?: MotionMode;
 }): import("react").JSX.Element;

package/dist/types/components/ui/accordion.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 export interface AccordionItem {
     value: string;
     title: ReactNode;

package/dist/types/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 import type { HTMLAttributes, ReactNode } from 'react';
 declare const badgeVariants: (props?: ({
-    tone?: "success" | "error" | "warning" | "info" | "primary" | "outline" | "neutral" | null | undefined;
+    tone?: "outline" | "success" | "error" | "warning" | "info" | "primary" | "neutral" | null | undefined;
     solid?: boolean | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {

package/dist/types/components/ui/brand-feedback-icon.d.ts

@@ -1,11 +1,10 @@
 import { type VariantProps } from 'class-variance-authority';
 import type { FeedbackType } from '../../brand/types';
 declare const iconVariants: (props?: ({
-    type?: "success" | "error" | "warning" | "info" | null | undefined;
     size?: "sm" | "lg" | "xl" | "2xl" | "md" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export declare const feedbackLabels: Record<FeedbackType, string>;
-export interface BrandFeedbackIconProps extends Omit<VariantProps<typeof iconVariants>, 'type'> {
+export interface BrandFeedbackIconProps extends VariantProps<typeof iconVariants> {
     type: FeedbackType;
     /** Texto para leitores de tela. Sem ele o ícone é decorativo (o texto ao lado informa). */
     label?: string;
@@ -15,6 +14,24 @@ export interface BrandFeedbackIconProps extends Omit<VariantProps<typeof iconVar
      * Troque a key do componente para repetir a animação.
      */
     animated?: boolean;
+    /**
+     * Cor do símbolo. `state` (padrão): a cor do estado (verde, vermelho, amarelo, azul).
+     * `brand`: a cor primária da marca (`text-primary-text`); o selo de estado mantém a cor do
+     * estado, para o significado não depender só da cor.
+     */
+    symbolTone?: 'state' | 'brand';
+    /**
+     * `false` (padrão): selo de estado sobreposto ao símbolo. `true`: o ícone do estado
+     * (Lucide, na cor do estado) fica ao lado do símbolo, no lugar do selo sobreposto. Com um
+     * SVG próprio em `brand.feedbackIcons[type]`, o SVG vence e nenhum selo é desenhado.
+     */
+    statusBadge?: boolean;
+    /**
+     * Só vale com `animated`. `pop` (padrão): entra com mola, o glifo se desenha e o erro
+     * treme. `encaixe`: entra em 240 ms, curva de saída suave, sem quique, sem desenho e sem
+     * tremor. Com "reduzir movimento" do sistema, nenhuma animação roda.
+     */
+    animation?: 'pop' | 'encaixe';
     className?: string;
 }
 /**
@@ -22,5 +39,5 @@ export interface BrandFeedbackIconProps extends Omit<VariantProps<typeof iconVar
  * semântica, com um selo de status para que o significado não dependa só da cor.
  * Cada tipo pode ser substituído por um SVG próprio em brand.config.ts (feedbackIcons).
  */
-export declare function BrandFeedbackIcon({ type, size, label, animated, className, }: BrandFeedbackIconProps): import("react").JSX.Element;
+export declare function BrandFeedbackIcon({ type, size, label, animated, symbolTone, statusBadge, animation, className, }: BrandFeedbackIconProps): import("react").JSX.Element;
 export {};

package/dist/types/components/ui/button-group.d.ts

@@ -16,6 +16,13 @@ interface ButtonGroupProps {
     onChange?: (value: string) => void;
     size?: 'sm' | 'md';
     fullWidth?: boolean;
+    /**
+     * Só no modo agrupado (`children`); o segmentado (`options`) ignora. `horizontal` (padrão):
+     * botões lado a lado. `vertical`: empilhados, na largura do grupo, com as bordas unidas.
+     * `responsive`: vertical abaixo de `md` e horizontal a partir dele (para três botões largos
+     * que não cabem em 360 px).
+     */
+    orientation?: 'horizontal' | 'vertical' | 'responsive';
     'aria-label'?: string;
     className?: string;
 }
@@ -23,5 +30,5 @@ interface ButtonGroupProps {
  * ButtonGroup único: agrupa botões de ação (children) ou funciona como controle
  * segmentado de escolha única (options + value).
  */
-export declare function ButtonGroup({ children, options, value, onChange, size, fullWidth, className, ...aria }: ButtonGroupProps): import("react").JSX.Element;
+export declare function ButtonGroup({ children, options, value, onChange, size, fullWidth, orientation, className, ...aria }: ButtonGroupProps): import("react").JSX.Element;
 export {};

package/dist/types/components/ui/button.d.ts

@@ -6,7 +6,7 @@ import { type ButtonHTMLAttributes, type ReactNode } from 'react';
  * Altura vem de h-control-*: 44px ou mais no mobile, compacta a partir de md.
  */
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "primary" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
+    variant?: "link" | "outline" | "primary" | "secondary" | "ghost" | "destructive" | null | undefined;
     size?: "sm" | "lg" | "md" | null | undefined;
     iconOnly?: boolean | null | undefined;
     fullWidth?: boolean | null | undefined;

package/dist/types/components/ui/dropdown-menu.d.ts

@@ -1,11 +1,11 @@
 import { DropdownMenu as D } from 'radix-ui';
-import type { ComponentProps } from 'react';
-export declare const DropdownMenu: import("react").FC<D.DropdownMenuProps>;
+import { type ComponentProps } from 'react';
+export declare function DropdownMenu(props: ComponentProps<typeof D.Root>): import("react").JSX.Element;
 export declare const DropdownMenuTrigger: import("react").ForwardRefExoticComponent<D.DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
 export declare const DropdownMenuGroup: import("react").ForwardRefExoticComponent<D.DropdownMenuGroupProps & import("react").RefAttributes<HTMLDivElement>>;
-export declare const DropdownMenuSub: import("react").FC<D.DropdownMenuSubProps>;
+export declare function DropdownMenuSub(props: ComponentProps<typeof D.Sub>): import("react").JSX.Element;
 export declare const DropdownMenuRadioGroup: import("react").ForwardRefExoticComponent<D.DropdownMenuRadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
-export declare function DropdownMenuContent({ className, sideOffset, ...props }: ComponentProps<typeof D.Content>): import("react").JSX.Element;
+export declare function DropdownMenuContent({ className, sideOffset, children, asChild, ...props }: ComponentProps<typeof D.Content>): import("react").JSX.Element;
 interface ItemProps extends ComponentProps<typeof D.Item> {
     /** Item destrutivo (excluir, sair): texto na cor destrutiva. */
     destructive?: boolean;
@@ -16,5 +16,5 @@ export declare function DropdownMenuRadioItem({ className, children, ...props }:
 export declare function DropdownMenuLabel({ className, ...props }: ComponentProps<typeof D.Label>): import("react").JSX.Element;
 export declare function DropdownMenuSeparator({ className, ...props }: ComponentProps<typeof D.Separator>): import("react").JSX.Element;
 export declare function DropdownMenuSubTrigger({ className, children, ...props }: ComponentProps<typeof D.SubTrigger>): import("react").JSX.Element;
-export declare function DropdownMenuSubContent({ className, ...props }: ComponentProps<typeof D.SubContent>): import("react").JSX.Element;
+export declare function DropdownMenuSubContent({ className, children, asChild, ...props }: ComponentProps<typeof D.SubContent>): import("react").JSX.Element;
 export {};

package/dist/types/components/ui/empty-state.d.ts

@@ -9,6 +9,10 @@ export interface EmptyStateProps {
     actions?: ReactNode;
     /** compact: dentro de tabela ou card pequeno. */
     size?: 'default' | 'compact';
+    /**
+     * Classes extras, que vencem as do componente. Para zerar o respiro vertical (por exemplo,
+     * dentro de um card que já tem o seu) use `className="py-0 md:py-0"`.
+     */
     className?: string;
 }
 /** Estado vazio (e de erro) com o ícone de feedback da marca. */

package/dist/types/components/ui/error-page.d.ts

@@ -5,9 +5,14 @@ export interface ErrorPageProps {
     description?: string;
     /** Ocupa a tela inteira (fora do AppShell). */
     fullScreen?: boolean;
+    /**
+     * Mostra o botão Voltar (padrão). Com `false` só a ação principal é desenhada, na largura
+     * toda (regra "um botão = 100%").
+     */
+    back?: boolean;
 }
 /**
  * Tela de erro única (404 e 500), com o ícone de feedback da marca animado.
  * Ações seguem a regra 30/70: secundária à esquerda, principal à direita.
  */
-export declare function ErrorPage({ code, title, description, fullScreen }: ErrorPageProps): import("react").JSX.Element;
+export declare function ErrorPage({ code, title, description, fullScreen, back, }: ErrorPageProps): import("react").JSX.Element;

package/dist/types/components/ui/modal.d.ts

@@ -15,6 +15,10 @@ export interface ModalProps {
     /** Conteúdo do body (em form, os campos). */
     children?: ReactNode;
     confirmLabel?: string;
+    /**
+     * Rótulo do botão de cancelar. Em `confirm` e `destructive` o padrão é "Cancelar". Em `info`
+     * não há botão de cancelar: o segundo botão só aparece quando `cancelLabel` é passado.
+     */
     cancelLabel?: string;
     /** Pode ser assíncrono: o botão mostra carregamento até terminar. */
     onConfirm?: () => void | Promise<void>;

package/dist/types/components/ui/picker-panel.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 interface PickerPanelProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;

package/dist/types/components/ui/popover.d.ts

@@ -1,6 +1,6 @@
 import { Popover as P } from 'radix-ui';
-import type { ComponentProps } from 'react';
-export declare const Popover: import("react").FC<P.PopoverProps>;
+import { type ComponentProps } from 'react';
+export declare function Popover(props: ComponentProps<typeof P.Root>): import("react").JSX.Element;
 export declare const PopoverTrigger: import("react").ForwardRefExoticComponent<P.PopoverTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
 export declare const PopoverClose: import("react").ForwardRefExoticComponent<P.PopoverCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
 export declare const PopoverAnchor: import("react").ForwardRefExoticComponent<P.PopoverAnchorProps & import("react").RefAttributes<HTMLDivElement>>;
@@ -8,5 +8,5 @@ interface PopoverContentProps extends ComponentProps<typeof P.Content> {
     /** Largura: sm (16rem) ou md (22rem). Sempre limitada à tela menos 32px. */
     width?: 'sm' | 'md';
 }
-export declare function PopoverContent({ className, align, sideOffset, width, ...props }: PopoverContentProps): import("react").JSX.Element;
+export declare function PopoverContent({ className, align, sideOffset, width, children, asChild, ...props }: PopoverContentProps): import("react").JSX.Element;
 export {};

package/dist/types/components/ui/radio-group.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 export interface RadioOption {
     value: string;
     label: ReactNode;

package/dist/types/components/ui/skeleton.d.ts

@@ -1,3 +1,7 @@
 import type { HTMLAttributes } from 'react';
-/** Bloco de carregamento. Monte o skeleton com a mesma estrutura do conteúdo final. */
+/**
+ * Bloco de carregamento. Monte o skeleton com a mesma estrutura do conteúdo final. Em `off` pulsa
+ * (animate-pulse do Tailwind); em `on` um brilho suave cruza o bloco (skeleton-shimmer, em
+ * globals.css: transform, tempo e curva pelos tokens, parado com "reduzir movimento").
+ */
 export declare function Skeleton({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/dist/types/components/ui/stat-card.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 export interface StatCardProps {
     label: string;
     value: ReactNode;

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

@@ -125,10 +125,4 @@ export interface TableProps<T> {
     /** Rótulo da tabela para leitores de tela. */
     'aria-label': string;
 }
-/**
- * Table única do sistema (TanStack Table). Tudo é prop: seleção, expansão, ordenação,
- * busca, colunas visíveis, ações em massa e por linha, densidade e estados.
- * Mobile (< 768px): a mesma tabela vira lista de cards, sem rolagem horizontal.
- * Desktop: tabela larga rola na horizontal só dentro do próprio contêiner.
- */
 export declare function Table<T>({ data: dataProp, source, queryKey, columns: columnsProp, statusLast, getRowId, selectable, expandable, sortable, globalFilter, columnVisibility, bulkActions, bulkMenu, rowActions, density, loading, error, onRetry, empty, pageSize: pageSizeProp, mobilePagination, toolbar, ...aria }: TableProps<T>): import("react").JSX.Element;

package/dist/types/components/ui/tooltip.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 /**
  * Tooltip: só para informação complementar, nunca essencial (não existe hover no toque).
  * Informação essencial vai em texto de ajuda visível ou em Popover acionado por toque.

package/dist/types/components/ui/wizard.d.ts

@@ -29,10 +29,23 @@ export interface WizardProps {
     onValidateStep?: (index: number) => boolean | Promise<boolean>;
     onFinish?: () => void | Promise<void>;
     onCancel?: () => void;
+    /** Rótulo do cancelar da primeira etapa (só aparece com `onCancel`). Padrão: "Cancelar". */
+    cancelLabel?: string;
+    /** Rótulo do voltar das etapas seguintes. Padrão: "Voltar". */
+    backLabel?: string;
+    /** Rótulo do avançar (todas as etapas menos a última). Padrão: "Avançar". */
+    nextLabel?: string;
     finishLabel?: string;
+    /**
+     * Torna a etapa opcional: "Pular" aparece no menu "Mais ações" da barra de ações (nunca na
+     * última etapa), avança **sem validar** e limpa o erro da etapa. Sem esta prop não há menu.
+     */
+    onSkip?: () => void;
+    /** Rótulo do item de pular. Padrão: "Pular". */
+    skipLabel?: string;
     orientation?: 'horizontal' | 'vertical';
     /** Botões no rodapé fixo da tela. Padrão: não, seguem junto do card do wizard. */
     stickyFooter?: boolean;
 }
 /** Cadastro em etapas, com validação por etapa e rodapé Voltar / Avançar. */
-export declare function Wizard({ steps, children, onValidateStep, onFinish, onCancel, finishLabel, orientation, stickyFooter, }: WizardProps): import("react").JSX.Element;
+export declare function Wizard({ steps, children, onValidateStep, onFinish, onCancel, cancelLabel, backLabel, nextLabel, finishLabel, onSkip, skipLabel, orientation, stickyFooter, }: WizardProps): import("react").JSX.Element;

package/dist/types/hooks/use-reduced-motion.d.ts

@@ -1 +1,4 @@
+/** Fonte única da preferência (também usada pelo motion, que só a assina em `on`). */
+export declare function subscribeReducedMotion(cb: () => void): () => void;
+export declare function getReducedMotion(): boolean;
 export declare function usePrefersReducedMotion(): boolean;

package/dist/types/index.d.ts

@@ -58,6 +58,7 @@ export * from './components/app-shell/app-shell';
 export * from './components/app-shell/layout';
 export * from './components/app-shell/types';
 export * from './components/rendra-provider';
+export type { MotionMode } from './lib/motion/motion-context';
 export * from './catalog/components';
 export * from './hooks/use-breakpoint';
 export * from './hooks/use-debounced-value';

package/dist/types/lib/initials.d.ts

@@ -0,0 +1,2 @@
+/** Iniciais de um nome: primeira letra do primeiro e do último nome, em maiúsculas. */
+export declare function initials(name: string): string;

package/dist/types/lib/motion/count.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+export interface ParsedNumber {
+    /** Tudo antes do número (inclui o sinal de menos). */
+    prefix: string;
+    /** Tudo depois do número. */
+    suffix: string;
+    /** Valor numérico (sem sinal no `prefix`: o sinal já está aqui). */
+    value: number;
+    decimals: number;
+    /** Separador de milhar "." (texto pt-BR que o usava). */
+    grouping: boolean;
+    /** Separador decimal: "," no texto pt-BR, "." no número do JavaScript. */
+    decimalSeparator: ',' | '.';
+}
+export declare function parseLocaleNumber(value: ReactNode): ParsedNumber | null;
+/** Escreve `n` com o mesmo formato do valor original. */
+export declare function formatLike(parsed: ParsedNumber, n: number): string;

package/dist/types/lib/motion/features-max.d.ts

@@ -0,0 +1 @@
+export { domMax as default } from 'motion/react';

package/dist/types/lib/motion/index.d.ts

@@ -0,0 +1,5 @@
+export { MotionModeScope, MotionProvider, RevealScope, useLayoutReady, useMotionMode, useRevealScope, type MotionMode, } from './motion-context';
+export { useMotionPresets } from './use-motion-presets';
+export type { MotionPreset, Presets, SlideDistance, SlideFrom } from './presets';
+export { layoutEnabled } from './reorder';
+export { formatLike, parseLocaleNumber, type ParsedNumber } from './count';

package/dist/types/lib/motion/motion-context.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from 'react';
+export type MotionMode = 'off' | 'on';
+/** Modo de motion do provider mais próximo (`off` sem provider). */
+export declare function useMotionMode(): MotionMode;
+/**
+ * Em `on`, o chunk do `domMax` já chegou. Um `m.*` com `layout` ou `layoutId` só ganha o nó de
+ * projeção se for criado DEPOIS disso (o Motion não monta a projeção de um elemento que já
+ * estava na tela), então quem usa layout liga a prop e remonta o item quando isto vira `true`.
+ */
+export declare function useLayoutReady(): boolean;
+/**
+ * Marca um trecho da árvore como "chegada de painel" (o dashboard): lá, o gráfico desenha no
+ * tempo do reveal (900 ms) em vez do tempo de rotina (`draw`, 420 ms). Fora dele, o gráfico de
+ * uma tela de uso diário desenha uma vez e rápido.
+ */
+export declare function RevealScope({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** O componente está dentro de um `RevealScope`? */
+export declare function useRevealScope(): boolean;
+/** Só troca o modo lido pelos componentes; não monta nem desmonta o LazyMotion. */
+export declare function MotionModeScope({ mode, children }: {
+    mode: MotionMode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Em `off`, só o contexto (nenhum nó novo, nenhum LazyMotion). Em `on`, dois `LazyMotion` (os
+ * dois `strict`: só `m.*` entra, um `motion.*` esquecido quebra em vez de puxar o pacote inteiro):
+ * o de fora carrega o `domMax` sob demanda (layout e arraste), em chunk separado; o de dentro traz
+ * o `domAnimation` síncrono (animação e gestos) e é o que os `m.*` enxergam. Nessa ordem o
+ * renderer síncrono já está no contexto na primeira renderização (elementos e gestos funcionam
+ * na hora), e os recursos de layout se juntam quando o chunk chega. A ordem contrária esconderia
+ * o renderer até o chunk terminar de baixar.
+ *
+ * O `MotionConfig` recebe "reduzir movimento" da mesma fonte dos presets (o `matchMedia` de
+ * `use-reduced-motion.ts`, reativo): com `always`, o Motion também tira o deslocamento e o layout
+ * de qualquer animação que um componente escreva à mão, e mantém a opacidade. Não é uma segunda
+ * fonte: é a primeira, lida uma vez, entregue a dois consumidores.
+ */
+export declare function MotionProvider({ mode, children }: {
+    mode: MotionMode;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/lib/motion/native-events.d.ts

@@ -0,0 +1,16 @@
+declare const NATIVE_EVENTS: {
+    readonly onDrag: "drag";
+    readonly onDragStart: "dragstart";
+    readonly onDragEnd: "dragend";
+    readonly onAnimationStart: "animationstart";
+};
+type NativeKey = keyof typeof NATIVE_EVENTS;
+type Handler = ((event: never) => void) | undefined;
+/** Separa as quatro chaves em conflito; o resto segue para o elemento do Motion. */
+export declare function splitNativeEvents<P extends object>(props: P): {
+    native: Partial<Record<"onDrag" | "onDragEnd" | "onDragStart" | "onAnimationStart", Handler>>;
+    rest: Omit<P, NativeKey>;
+};
+/** Liga os manipuladores como ouvintes nativos. Devolve a função que os remove. */
+export declare function bindNativeEvents(el: HTMLElement, native: Partial<Record<NativeKey, Handler>>): () => void;
+export {};

package/dist/types/lib/motion/presets.d.ts

@@ -0,0 +1,92 @@
+import type { Target, TargetAndTransition, Transition } from 'motion/react';
+import { type Bezier, type MotionTokens } from './tokens';
+export interface MotionPreset {
+    initial: Target;
+    animate: TargetAndTransition;
+    exit: TargetAndTransition;
+    transition: Transition;
+}
+/** Toque: o alvo do `whileTap` (`undefined` no reduzido) e a transição de ida e de volta. */
+export interface PressPreset {
+    whileTap: TargetAndTransition | undefined;
+    transition: Transition;
+}
+export type SlideFrom = 'left' | 'right' | 'top' | 'bottom';
+/** Distância do slide: `full` (painel que entra da borda) ou `short` (conteúdo que assenta). */
+export type SlideDistance = 'full' | 'short';
+export interface Presets {
+    reduced: boolean;
+    /** Toque do botão, do polegar e dos controles: 120 ms, `ease.out`, escala 0,97. */
+    press: PressPreset;
+    /** Alias de `press.whileTap`, o nome antigo. Sem movimento reduzido vem `undefined`. */
+    tap: TargetAndTransition | undefined;
+    /**
+     * Salto curto de escala (célula do OTP), com a transição dentro do alvo. Estável entre
+     * renders; `undefined` se reduzido.
+     */
+    bump: TargetAndTransition | undefined;
+    tokens: MotionTokens;
+    fade: MotionPreset;
+    /** Alias de `open()`: escala 0,95 com mola a partir da origem, saída rápida só em opacidade. */
+    scale: MotionPreset;
+    /**
+     * Cota rara de encanto (check do passo concluído): 0,8 -> 1 com a curva back, em `slow`. Nunca
+     * em controle de uso frequente.
+     */
+    pop: MotionPreset;
+    /**
+     * Indicador de controle frequente (check do Checkbox, ponto do Radio): 0,9 -> 1 com opacidade
+     * em `fast`, sem quique e sem partir de zero.
+     */
+    indicator: MotionPreset;
+    slide: (from: SlideFrom, distance?: SlideDistance) => MotionPreset;
+    /**
+     * Overlay ancorado (popover, menu, modal, painel do select). Número = escala de partida
+     * (padrão 0,95); `{ y }` = entrada plana, sem escala, para a superfície em tela cheia.
+     * Entra em mola criticamente amortecida (sem quique) em `base` e sai em `fast`, em opacidade.
+     */
+    open: (from?: number | {
+        y: number;
+    }) => MotionPreset;
+    /** Gaveta e folha: entram de `from` em `slow` com `ease.drawer`, saem em `fast` pelo mesmo lado. */
+    sheet: (from: SlideFrom) => MotionPreset;
+    /** Tooltip: escala 0,97 em `fast`; aberto em `instant-open` não anima. */
+    tooltip: (instant: boolean) => MotionPreset;
+    /**
+     * Troca de conteúdo no lugar (passo do wizard), sem esperar a saída: o que sai esmaece com
+     * `blur` de 2 px em `fast`; o que entra vem de `direction` (1 avança, -1 volta), 8 px, em
+     * `base`. O desfoque disfarça o cruzamento: sem ele o olho vê dois objetos trocando de lugar.
+     */
+    swap: (direction: 1 | -1) => MotionPreset;
+    /**
+     * Entrada de uso único (reveal do dashboard): desloca 8 px e dura `reveal.enter`, mais lenta
+     * que `slide`. Não serve a interação repetida (overlay, tab, botão).
+     */
+    reveal: (from: SlideFrom) => MotionPreset;
+    /** Deslocamento na tela (indicador, reordenação): `move` em `ease.move`. */
+    move: Transition;
+    /** Nome antigo de `move`. */
+    layout: Transition;
+    /** Mola sem quique: onde há gesto ou soltura (drop do kanban, folha que volta). */
+    settle: Transition;
+    /** Mola da folha depois do arraste (quique mínimo). */
+    springSheet: Transition;
+    /**
+     * A mesma mola da folha em rigidez e amortecimento (massa 1), que é o que o arraste do Motion
+     * (`dragTransition`) pede para a volta à origem: rigidez = (2π / duração)², amortecimento =
+     * 2 (1 - quique) raiz(rigidez).
+     */
+    sheetBounce: {
+        bounceStiffness: number;
+        bounceDamping: number;
+    };
+    /** Atraso de entrada do item `index`, limitado a `limit` itens (padrão 8: 480 ms). */
+    stagger: (index: number, limit?: number) => Transition;
+    /** Atraso do bloco `index` no reveal (passo `reveal.stagger`), limitado a `limit` blocos. */
+    staggerReveal: (index: number, limit?: number) => Transition;
+}
+export declare function createPresets(tokens: MotionTokens, reduced: boolean): Presets;
+/** Curva no formato do recharts: `cubic-bezier(a,b,c,d)`, sem espaços. */
+export declare function toCubicBezier([a, b, c, d,]: Bezier): `cubic-bezier(${number},${number},${number},${number})`;
+/** Presets com os tokens lidos agora do documento. */
+export declare function presetsFromDocument(reduced: boolean): Presets;

package/dist/types/lib/motion/reorder.d.ts

@@ -0,0 +1,7 @@
+import type { MotionMode } from './motion-context';
+export declare function layoutEnabled({ mode, ready, dragging, }: {
+    mode: MotionMode;
+    /** O chunk do `domMax` já chegou (`useLayoutReady`). Antes disso `layout` não faz nada. */
+    ready: boolean;
+    dragging: boolean;
+}): boolean;