forlogic-core 2.1.5 → 2.2.1

package/dist/components/ui/action-button.d.ts

@@ -1,5 +1,10 @@
 import React from 'react';
 import { type ButtonProps } from './button';
+/**
+ * Props do `ActionButton`. Aceita variantes de botão e qualquer atributo HTML de `<button>`.
+ * @example
+ * const props: ActionButtonProps = { variant: 'action-secondary', onClick: openMenu };
+ */
 interface ActionButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
     children?: React.ReactNode;
     variant?: ButtonProps['variant'];

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

@@ -1,20 +1,102 @@
+/**
+ * @module AlertDialog
+ * Diálogo modal **não-dismissable** para confirmação de ações destrutivas/irreversíveis
+ * (excluir, descartar). Difere de `Dialog`: não pode ser fechado clicando fora ou ESC sem
+ * uma escolha explícita (`AlertDialogAction` ou `AlertDialogCancel`).
+ *
+ * Para diálogos de formulário, edição ou exibição livre de conteúdo, use `Dialog`.
+ *
+ * @example
+ * ```tsx
+ * <AlertDialog>
+ *   <AlertDialogTrigger asChild><Button variant="danger">Excluir</Button></AlertDialogTrigger>
+ *   <AlertDialogContent>
+ *     <AlertDialogHeader>
+ *       <AlertDialogTitle>Confirmar exclusão</AlertDialogTitle>
+ *       <AlertDialogDescription>Esta ação não pode ser desfeita.</AlertDialogDescription>
+ *     </AlertDialogHeader>
+ *     <AlertDialogFooter>
+ *       <AlertDialogCancel>Cancelar</AlertDialogCancel>
+ *       <AlertDialogAction onClick={onDelete}>Excluir</AlertDialogAction>
+ *     </AlertDialogFooter>
+ *   </AlertDialogContent>
+ * </AlertDialog>
+ * ```
+ *
+ * @see `docs/design-system/dialogs.md`
+ */
 import * as React from "react";
 import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+/**
+ * Raiz do AlertDialog. Controla estado open/onOpenChange.
+ * @example
+ * <AlertDialog open={open} onOpenChange={setOpen}>...</AlertDialog>
+ */
 declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+/**
+ * Elemento que dispara a abertura do AlertDialog. Use `asChild` para customizar.
+ * @example
+ * <AlertDialogTrigger asChild><Button variant="danger">Excluir</Button></AlertDialogTrigger>
+ */
 declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Portal que renderiza o conteúdo fora da árvore DOM atual.
+ * @example
+ * <AlertDialogPortal><AlertDialogOverlay /><AlertDialogContent>...</AlertDialogContent></AlertDialogPortal>
+ */
 declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+/**
+ * Overlay escuro renderizado atrás do conteúdo. Usado internamente por `AlertDialogContent`.
+ * @example
+ * <AlertDialogPortal><AlertDialogOverlay /></AlertDialogPortal>
+ */
 declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Container do conteúdo modal centralizado. Inclui automaticamente Portal e Overlay.
+ * @example
+ * <AlertDialogContent><AlertDialogHeader>...</AlertDialogHeader></AlertDialogContent>
+ */
 declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Cabeçalho do AlertDialog. Agrupa `AlertDialogTitle` e `AlertDialogDescription`.
+ * @example
+ * <AlertDialogHeader><AlertDialogTitle>Confirmar</AlertDialogTitle></AlertDialogHeader>
+ */
 declare const AlertDialogHeader: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+/**
+ * Rodapé do AlertDialog. Alinha botões de ação à direita em desktop.
+ * @example
+ * <AlertDialogFooter><AlertDialogCancel>Cancelar</AlertDialogCancel><AlertDialogAction>OK</AlertDialogAction></AlertDialogFooter>
+ */
 declare const AlertDialogFooter: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+/**
+ * Título do AlertDialog (text-lg, font-semibold).
+ * @example
+ * <AlertDialogTitle>Confirmar exclusão</AlertDialogTitle>
+ */
 declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Descrição/contexto da ação (text-sm, muted).
+ * @example
+ * <AlertDialogDescription>Esta ação não pode ser desfeita.</AlertDialogDescription>
+ */
 declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Botão de ação confirmatória. Estiliza com `buttonVariants()` padrão.
+ * @example
+ * <AlertDialogAction onClick={onDelete}>Excluir</AlertDialogAction>
+ */
 declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Botão de cancelamento (variante outline). Fecha o dialog sem confirmar.
+ * @example
+ * <AlertDialogCancel>Cancelar</AlertDialogCancel>
+ */
 declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

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

@@ -4,9 +4,41 @@ declare const alertVariants: (props?: {
     variant?: "danger" | "success" | "warning" | "info";
 } & import("class-variance-authority/types").ClassProp) => string;
 interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    /** Exibe o ícone semântico automático da variante (default `true`). */
     showIcon?: boolean;
 }
+/**
+ * Bloco de mensagem semântica com ícone automático por variante.
+ *
+ * Variantes (todas com tokens dedicados em `index.css`):
+ * - `info` (default): Info azul — informações neutras.
+ * - `warning`: Atenção amarela — atenção sem bloqueio.
+ * - `danger`: AlertTriangle vermelho — erro ou ação destrutiva. **Use `danger`, não `destructive`.**
+ * - `success`: CheckCircle verde — confirmação.
+ *
+ * Composição: `Alert` (raiz) + `AlertTitle` (opcional) + `AlertDescription`.
+ *
+ * @example
+ * ```tsx
+ * <Alert variant="warning">
+ *   <AlertTitle>Atenção</AlertTitle>
+ *   <AlertDescription>Existem alterações não salvas.</AlertDescription>
+ * </Alert>
+ * ```
+ *
+ * @see `docs/design-system/notifications-feedback.md`
+ */
 declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `AlertTitle` da lib.
+ * @example
+ * <AlertTitle />
+ */
 declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Componente `AlertDescription` da lib.
+ * @example
+ * <AlertDescription />
+ */
 declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
 export { Alert, AlertTitle, AlertDescription };

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

@@ -1,6 +1,36 @@
+/**
+ * @module Avatar
+ * Avatar circular com fallback automático. Composto por `Avatar` (raiz) +
+ * `AvatarImage` (imagem) + `AvatarFallback` (iniciais quando imagem falha).
+ *
+ * @example
+ * ```tsx
+ * <Avatar>
+ *   <AvatarImage src={user.photoUrl} alt={user.name} />
+ *   <AvatarFallback>{getInitials(user.name)}</AvatarFallback>
+ * </Avatar>
+ * ```
+ *
+ * @see `docs/design-system/data-display.md`
+ */
 import * as React from "react";
 import * as AvatarPrimitive from "@radix-ui/react-avatar";
+/**
+ * Container circular do avatar (default 40x40, `rounded-full`).
+ * @example
+ * <Avatar><AvatarFallback>JD</AvatarFallback></Avatar>
+ */
 declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Imagem do avatar. Se falhar ao carregar, exibe automaticamente o `AvatarFallback`.
+ * @example
+ * <AvatarImage src="/users/joao.jpg" alt="João" />
+ */
 declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+/**
+ * Fallback exibido quando `AvatarImage` falha. Use iniciais ou ícone.
+ * @example
+ * <AvatarFallback>JD</AvatarFallback>
+ */
 declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
 export { Avatar, AvatarImage, AvatarFallback };

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

@@ -1,9 +1,41 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
+/**
+ * CVA com variantes do `Badge`. Exportado para compor estilos em outros componentes.
+ * @example
+ * <div className={badgeVariants({ variant: 'success' })}>Custom</div>
+ */
 declare const badgeVariants: (props?: {
     variant?: "secondary" | "outline" | "danger" | "default" | "success" | "warning" | "info" | "sharp";
 } & import("class-variance-authority/types").ClassProp) => string;
+/**
+ * Tipo `BadgeProps` exportado pela lib.
+ * @example
+ * const value: BadgeProps = {} as BadgeProps;
+ */
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }
+/**
+ * Etiqueta visual compacta para metadados, contagens ou estados estáticos.
+ *
+ * Variantes:
+ * - `default`: marca primária (azul).
+ * - `secondary`: neutro suave.
+ * - `danger`: erros / ações destrutivas. **Use `danger`, não `destructive`** (padrão da lib).
+ * - `outline`: apenas borda, sem fundo.
+ * - `success` / `warning` / `info`: feedback semântico.
+ * - `sharp`: variante verde-limão de destaque (uso pontual).
+ *
+ * Para estados dinâmicos de processo (Ativo, Pendente, Concluído), prefira
+ * `StatusBadge` da lib (gera cor pastel automaticamente).
+ *
+ * @example
+ * ```tsx
+ * <Badge variant="success">Aprovado</Badge>
+ * <Badge variant="info">Novo</Badge>
+ * ```
+ *
+ * @see Documentação: `docs/design-system/data-display.md`
+ */
 declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLDivElement>>;
 export { Badge, badgeVariants };

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

@@ -1,17 +1,71 @@
+/**
+ * @module Breadcrumb
+ * Trilha de navegação hierárquica. Composto por `Breadcrumb` > `BreadcrumbList` >
+ * `BreadcrumbItem` (com `BreadcrumbLink` ou `BreadcrumbPage`) intercalados por
+ * `BreadcrumbSeparator`. Use `BreadcrumbEllipsis` para colapsar níveis intermediários.
+ *
+ * @example
+ * ```tsx
+ * <Breadcrumb>
+ *   <BreadcrumbList>
+ *     <BreadcrumbItem><BreadcrumbLink href="/">Home</BreadcrumbLink></BreadcrumbItem>
+ *     <BreadcrumbSeparator />
+ *     <BreadcrumbItem><BreadcrumbPage>Atual</BreadcrumbPage></BreadcrumbItem>
+ *   </BreadcrumbList>
+ * </Breadcrumb>
+ * ```
+ *
+ * @see `docs/design-system/navigation.md`
+ */
 import * as React from "react";
+/**
+ * Raiz `<nav aria-label="breadcrumb">`. Aceite separator customizado via prop.
+ * @example
+ * <Breadcrumb><BreadcrumbList>...</BreadcrumbList></Breadcrumb>
+ */
 declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
     separator?: React.ReactNode;
 } & React.RefAttributes<HTMLElement>>;
+/**
+ * Lista ordenada `<ol>` que envolve os items.
+ * @example
+ * <BreadcrumbList><BreadcrumbItem>...</BreadcrumbItem></BreadcrumbList>
+ */
 declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+/**
+ * Item individual `<li>`. Contém um `BreadcrumbLink` ou `BreadcrumbPage`.
+ * @example
+ * <BreadcrumbItem><BreadcrumbLink href="/users">Usuários</BreadcrumbLink></BreadcrumbItem>
+ */
 declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+/**
+ * Link clicável do breadcrumb. Use `asChild` para integrar com React Router.
+ * @example
+ * <BreadcrumbLink asChild><Link to="/users">Usuários</Link></BreadcrumbLink>
+ */
 declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
     asChild?: boolean;
 } & React.RefAttributes<HTMLAnchorElement>>;
+/**
+ * Página atual (não clicável). Marca semanticamente com `aria-current="page"`.
+ * @example
+ * <BreadcrumbPage>Editar usuário</BreadcrumbPage>
+ */
 declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Separador entre items (default: ChevronRight). Aceita ícone customizado como children.
+ * @example
+ * <BreadcrumbSeparator><Slash /></BreadcrumbSeparator>
+ */
 declare const BreadcrumbSeparator: {
     ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+/**
+ * Indicador "..." para colapsar níveis intermediários em trilhas longas.
+ * @example
+ * <BreadcrumbItem><BreadcrumbEllipsis /></BreadcrumbItem>
+ */
 declare const BreadcrumbEllipsis: {
     ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
     displayName: string;

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

@@ -1,9 +1,24 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
+/**
+ * `buttonGroupVariants` exportado pela lib.
+ * @example
+ * buttonGroupVariants;
+ */
 declare const buttonGroupVariants: (props?: {
     orientation?: "horizontal" | "vertical";
 } & import("class-variance-authority/types").ClassProp) => string;
+/**
+ * Tipo `ButtonGroupProps` exportado pela lib.
+ * @example
+ * const value: ButtonGroupProps = {} as ButtonGroupProps;
+ */
 export interface ButtonGroupProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof buttonGroupVariants> {
 }
+/**
+ * Componente `ButtonGroup` da lib.
+ * @example
+ * <ButtonGroup />
+ */
 declare const ButtonGroup: React.ForwardRefExoticComponent<ButtonGroupProps & React.RefAttributes<HTMLDivElement>>;
 export { ButtonGroup, buttonGroupVariants };

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

@@ -1,11 +1,66 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
+/**
+ * Variantes de estilo do componente {@link Button}.
+ *
+ * Variantes ativas:
+ * - `primary` (default): Ação principal (bg azul). Use para CTA único na tela.
+ * - `secondary`: Ação secundária com borda.
+ * - `tertiary`: Borda suave + bg neutro.
+ * - `outline` / `ghost` / `subtle`: Variações de baixa ênfase.
+ * - `destructive` / `danger`: Ações irreversíveis (excluir). Aliases entre si — prefira `danger` (padrão da lib).
+ * - `link`: Aparência de hyperlink, sem fundo.
+ * - `icon`: Botão quadrado para apenas ícone (use `size="icon"`).
+ *
+ * Variantes legadas (mantidas por compatibilidade — evite em código novo):
+ * `default`, `action`, `icon-only`, `external-link`, `action-primary`, `action-secondary`.
+ *
+ * @see {@link Button}
+ *
+ * @example
+ * buttonVariants;
+ */
 declare const buttonVariants: (props?: {
     variant?: "link" | "icon" | "primary" | "secondary" | "tertiary" | "outline" | "ghost" | "subtle" | "destructive" | "danger" | "loading" | "default" | "action" | "icon-only" | "external-link" | "action-primary" | "action-secondary";
     size?: "icon" | "default" | "sm" | "md" | "lg" | "xl" | "icon-sm" | "icon-xs";
 } & import("class-variance-authority/types").ClassProp) => string;
+/**
+ * Tipo `ButtonProps` exportado pela lib.
+ * @example
+ * const value: ButtonProps = {} as ButtonProps;
+ */
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /**
+     * Quando `true`, renderiza o filho ao invés de um `<button>`, repassando todos os estilos.
+     * Útil para combinar com `<Link>` do React Router ou outros wrappers.
+     *
+     * @example
+     * ```tsx
+     * <Button asChild><Link to="/home">Início</Link></Button>
+     * ```
+     */
     asChild?: boolean;
 }
+/**
+ * Botão padrão da Forlogic Core. Suporta variantes semânticas, tamanhos, ícones (SVG inline)
+ * e composição via `asChild`.
+ *
+ * @example Ação primária
+ * ```tsx
+ * <Button variant="primary" size="md">Salvar</Button>
+ * ```
+ *
+ * @example Ação destrutiva com ícone
+ * ```tsx
+ * <Button variant="danger"><Trash2 /> Excluir</Button>
+ * ```
+ *
+ * @example Botão de ícone apenas
+ * ```tsx
+ * <Button variant="icon" size="icon" aria-label="Editar"><Pencil /></Button>
+ * ```
+ *
+ * @see Documentação completa: `docs/design-system/buttons-actions.md`
+ */
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
 export { Button, buttonVariants };

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

@@ -1,6 +1,22 @@
 import * as React from "react";
 import { DayPicker } from "react-day-picker";
+/**
+ * Props do `Calendar`. Estende todas as props de `react-day-picker`.
+ * @example
+ * const props: CalendarProps = { mode: 'single', selected: date, onSelect: setDate };
+ */
 export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+/**
+ * Calendário pt-BR (via date-fns/locale). Wrapper estilizado de `react-day-picker`.
+ *
+ * @example
+ * ```tsx
+ * <Calendar mode="single" selected={date} onSelect={setDate} />
+ * <Calendar mode="range" selected={range} onSelect={setRange} />
+ * ```
+ *
+ * @see `docs/design-system/inputs.md`
+ */
 declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Calendar {
     var displayName: string;

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

@@ -1,8 +1,57 @@
+/**
+ * @module Card
+ * Container visual com borda e sombra suave. Composto por:
+ * `Card` (raiz) → `CardHeader` (com `CardTitle` + `CardDescription`) → `CardContent` → `CardFooter`.
+ *
+ * @example
+ * ```tsx
+ * <Card>
+ *   <CardHeader>
+ *     <CardTitle>Resumo do mês</CardTitle>
+ *     <CardDescription>Indicadores de abril</CardDescription>
+ *   </CardHeader>
+ *   <CardContent>{children}</CardContent>
+ *   <CardFooter><Button>Ver detalhes</Button></CardFooter>
+ * </Card>
+ * ```
+ *
+ * @see `docs/design-system/data-display.md`
+ */
 import * as React from "react";
+/**
+ * Raiz do card (`rounded-lg border bg-card shadow-sm`).
+ * @example
+ * <Card><CardHeader>...</CardHeader></Card>
+ */
 declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Cabeçalho do card (padding 6, espaçamento vertical entre título/descrição).
+ * @example
+ * <CardHeader><CardTitle>Vendas</CardTitle></CardHeader>
+ */
 declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Título do card (`<h3>`, text-2xl, semibold).
+ * @example
+ * <CardTitle>Resumo</CardTitle>
+ */
 declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Descrição/subtítulo do card (text-sm muted).
+ * @example
+ * <CardDescription>Últimos 30 dias</CardDescription>
+ */
 declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Corpo principal do card. Padding sem top (continua do header).
+ * @example
+ * <CardContent><p>Conteúdo</p></CardContent>
+ */
 declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Rodapé do card. Padrão flex-row alinhado ao centro vertical.
+ * @example
+ * <CardFooter><Button>Ver mais</Button></CardFooter>
+ */
 declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -4,6 +4,11 @@ declare const THEMES: {
     readonly light: "";
     readonly dark: ".dark";
 };
+/**
+ * Tipo `ChartConfig` exportado pela lib.
+ * @example
+ * const value: ChartConfig = {} as ChartConfig;
+ */
 export type ChartConfig = {
     [k in string]: {
         label?: React.ReactNode;
@@ -16,14 +21,29 @@ export type ChartConfig = {
         theme: Record<keyof typeof THEMES, string>;
     });
 };
+/**
+ * Componente `ChartContainer` da lib.
+ * @example
+ * <ChartContainer />
+ */
 declare const ChartContainer: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
     config: ChartConfig;
     children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
 }, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `ChartStyle` da lib.
+ * @example
+ * <ChartStyle />
+ */
 declare const ChartStyle: ({ id, config }: {
     id: string;
     config: ChartConfig;
 }) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente `ChartTooltip` da lib.
+ * @example
+ * <ChartTooltip />
+ */
 declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
 interface ChartTooltipContentProps extends React.ComponentProps<"div"> {
     active?: boolean;
@@ -46,7 +66,17 @@ interface ChartTooltipContentProps extends React.ComponentProps<"div"> {
     labelClassName?: string;
     color?: string;
 }
+/**
+ * Componente `ChartTooltipContent` da lib.
+ * @example
+ * <ChartTooltipContent />
+ */
 declare const ChartTooltipContent: React.ForwardRefExoticComponent<Omit<ChartTooltipContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `ChartLegend` da lib.
+ * @example
+ * <ChartLegend />
+ */
 declare const ChartLegend: React.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
 interface ChartLegendContentProps extends React.ComponentProps<"div"> {
     payload?: Array<{
@@ -58,5 +88,10 @@ interface ChartLegendContentProps extends React.ComponentProps<"div"> {
     hideIcon?: boolean;
     nameKey?: string;
 }
+/**
+ * Componente `ChartLegendContent` da lib.
+ * @example
+ * <ChartLegendContent />
+ */
 declare const ChartLegendContent: React.ForwardRefExoticComponent<Omit<ChartLegendContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, };

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

@@ -1,4 +1,15 @@
 import * as React from "react";
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+/**
+ * Caixa de seleção binária (16x16). Suporta estados controlado/não controlado e indeterminate.
+ *
+ * @example
+ * ```tsx
+ * <Checkbox checked={agreed} onCheckedChange={setAgreed} id="terms" />
+ * <Label htmlFor="terms">Aceito os termos</Label>
+ * ```
+ *
+ * @see `docs/design-system/inputs.md`
+ */
 declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export { Checkbox };

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

@@ -1,5 +1,20 @@
 import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+/**
+ * Componente `Collapsible` da lib.
+ * @example
+ * <Collapsible />
+ */
 declare const Collapsible: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `CollapsibleTrigger` da lib.
+ * @example
+ * <CollapsibleTrigger />
+ */
 declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+/**
+ * Componente `CollapsibleContent` da lib.
+ * @example
+ * <CollapsibleContent />
+ */
 declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
 export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/ui/color-picker.d.ts

@@ -8,5 +8,10 @@ interface ColorPickerProps {
     /** i18n: Label for preset colors section (default: t('preset_colors')) */
     presetColorsLabel?: string;
 }
+/**
+ * Componente `ColorPicker` da lib.
+ * @example
+ * <ColorPicker />
+ */
 export declare const ColorPicker: React.FC<ColorPickerProps>;
 export {};

package/dist/components/ui/combo-tree.d.ts

@@ -75,4 +75,27 @@ export interface ComboTreeProps {
     /** Whether parent nodes start expanded. Defaults to true. */
     defaultExpanded?: boolean;
 }
+/**
+ * ComboTree — Combobox para dados hierárquicos (tree view). Chevron expande/colapsa
+ * subgrupos, label seleciona o item. Busca filtra recursivamente preservando ancestrais
+ * e auto-expande os ramos com matches.
+ *
+ * Alias disponível: `TreeSelect` (padrão Ant Design / Syncfusion).
+ *
+ * @example
+ * const options: ComboTreeOption[] = [
+ *   { value: 'qa', label: 'Qualidade', children: [
+ *     { value: 'docs', label: 'Documentos' },
+ *     { value: 'occ',  label: 'Ocorrências' },
+ *   ]},
+ *   { value: 'hr', label: 'RH' },
+ * ];
+ *
+ * <ComboTree
+ *   options={options}
+ *   value={selectedNode}
+ *   onChange={setSelectedNode}
+ *   placeholder="Selecionar módulo..."
+ * />
+ */
 export declare function ComboTree({ multiple, options, value, onChange, placeholder, label, icon: Icon, emptyMessage, searchPlaceholder, disabled, required, isLoading, error, className, maxDisplayedBadges, popoverContainer, onOpen, onClose, defaultExpanded, }: ComboTreeProps): import("react/jsx-runtime").JSX.Element;

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

@@ -27,6 +27,34 @@ export interface ComboboxProps<T = any> {
     items?: T[];
     onValueChange?: (value: string | string[]) => void;
 }
+/**
+ * Combobox — componente de seleção (única ou múltipla) com busca, suporte a
+ * objetos customizados via `getOptionValue`/`getOptionLabel`, badges para
+ * valores selecionados e integração com Dialogs (use `popoverContainer`).
+ *
+ * Para a documentação completa de props e variantes, veja o JSDoc no topo
+ * deste arquivo. Aliases: `SelectSearch`, `MultiSelect`, `EntitySelect`, `AutoComplete`.
+ *
+ * @example
+ * <Combobox
+ *   options={users}
+ *   value={selectedId}
+ *   onChange={setSelectedId}
+ *   getOptionValue={(u) => u.id}
+ *   getOptionLabel={(u) => u.name}
+ *   placeholder="Selecionar responsável..."
+ * />
+ *
+ * @example
+ * // Múltipla seleção com badges
+ * <Combobox
+ *   multiple
+ *   options={tags}
+ *   value={selectedTagIds}
+ *   onChange={setSelectedTagIds}
+ *   maxDisplayedBadges={3}
+ * />
+ */
 export declare function Combobox<T = any>({ multiple, options: optionsProp, items, // alias
 value, onChange: onChangeProp, onValueChange, // alias
 getOptionValue, getOptionLabel, placeholder, label, icon, emptyMessage, searchPlaceholder, disabled, required, isLoading, error, className, sortOptions, maxDisplayedBadges, popoverContainer, onOpen, onClose }: ComboboxProps<T>): import("react/jsx-runtime").JSX.Element;