forlogic-core 2.2.7 → 2.3.0

package/dist/places/components/layout/AppHeader.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface AppHeaderProps {
+    actions?: React.ReactNode;
+}
+declare const AppHeader: React.NamedExoticComponent<AppHeaderProps>;
+export default AppHeader;

package/dist/places/components/layout/AppLayout.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { SidebarConfig } from '../../types/sidebar';
+interface AppLayoutProps {
+    children: ReactNode;
+    sidebar?: ReactNode;
+    sidebarConfig?: SidebarConfig;
+    showHeader?: boolean;
+}
+export declare const AppLayout: import("react").NamedExoticComponent<AppLayoutProps>;
+export {};

package/dist/places/components/layout/AppSidebar.d.ts

@@ -0,0 +1,10 @@
+import { SidebarConfig } from '../../types/sidebar';
+interface AppSidebarProps {
+    config?: SidebarConfig;
+    customContent?: React.ReactNode;
+    resizable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+}
+export declare function AppSidebar({ config, customContent, resizable, minWidth, maxWidth }?: AppSidebarProps): import("react/jsx-runtime").JSX.Element;
+export default AppSidebar;

package/dist/places/components/layout/BodyContent.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+export interface BreadcrumbItemConfig {
+    /** Texto do item */
+    label: string;
+    /** Link de navegação (não incluir para página atual) */
+    href?: string;
+    /** Componente customizado para o link (ex: Link do React Router) */
+    asChild?: boolean;
+    /** Elemento filho quando asChild é true */
+    children?: React.ReactNode;
+}
+export interface BodyContentProps {
+    /** Itens do breadcrumb */
+    breadcrumbs?: BreadcrumbItemConfig[];
+    /** Conteúdo principal */
+    children: React.ReactNode;
+    /** Classes CSS adicionais para o container externo */
+    className?: string;
+}
+export interface ContentContainerProps {
+    /** Título do container (opcional) */
+    title?: string;
+    /** Subtítulo do container (opcional) */
+    subtitle?: string;
+    /** Conteúdo do container */
+    children?: React.ReactNode;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Se o container tem header com título/subtítulo separado do conteúdo */
+    hasHeader?: boolean;
+}
+/**
+ * Container de conteúdo branco com título e subtítulo opcionais.
+ * Pode ser usado múltiplas vezes dentro do BodyContent.
+ */
+export declare function ContentContainer({ title, subtitle, children, className, hasHeader, }: ContentContainerProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * BodyContent - Container principal de página
+ *
+ * Componente de layout que encapsula o conteúdo da página com:
+ * - Background na cor Escala Neutra 100 (#F5F5F5)
+ * - Breadcrumb no topo
+ * - Suporte a múltiplos ContentContainers
+ *
+ * @example
+ * ```tsx
+ * <BodyContent
+ *   breadcrumbs={[
+ *     { label: 'Módulo', href: '/modulo' },
+ *     { label: 'Seção 1', href: '/modulo/secao1' },
+ *     { label: 'Seção 2' }, // Página atual (sem href)
+ *   ]}
+ * >
+ *   <ContentContainer title="Título" subtitle="Subtítulo">
+ *     Conteúdo aqui
+ *   </ContentContainer>
+ * </BodyContent>
+ * ```
+ */
+export declare function BodyContent({ breadcrumbs, children, className, }: BodyContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/layout/SidebarActionTrigger.d.ts

@@ -0,0 +1,46 @@
+import { SidebarActionsConfig } from '../../types/sidebar';
+export interface SidebarActionTriggerProps {
+    /** Configuração das ações do módulo */
+    config: SidebarActionsConfig;
+    /** Se a sidebar está colapsada (modo ícone) */
+    isCollapsed?: boolean;
+    /** Desabilita o gatilho (ex: quando há modais abertos) */
+    isDisabled?: boolean;
+    /** Classes adicionais */
+    className?: string;
+}
+/**
+ * SidebarActionTrigger - Gatilho de ações principais do módulo
+ *
+ * Exibe um botão de ação destacado no topo do sidebar.
+ * - variant='button' (padrão): Uma ação executa direto, múltiplas exibem dropdown
+ * - variant='split-button': Primeira ação é o botão principal, demais no dropdown
+ *
+ * @example
+ * ```tsx
+ * // Modo button (padrão)
+ * <SidebarActionTrigger
+ *   config={{
+ *     triggerLabel: 'Criar',
+ *     actions: [
+ *       { id: 'new-item', label: t('new_item'), onClick: () => openDialog() }
+ *     ]
+ *   }}
+ *   isCollapsed={!open}
+ * />
+ *
+ * // Modo split-button
+ * <SidebarActionTrigger
+ *   config={{
+ *     variant: 'split-button',
+ *     actions: [
+ *       { id: 'new-doc', label: t('new_document'), icon: FilePlus, onClick: handleNewDoc },
+ *       { id: 'new-folder', label: t('new_folder'), icon: FolderPlus, onClick: handleNewFolder },
+ *     ]
+ *   }}
+ *   isCollapsed={!open}
+ * />
+ * ```
+ */
+export declare function SidebarActionTrigger({ config, isCollapsed, isDisabled, className, }: SidebarActionTriggerProps): import("react/jsx-runtime").JSX.Element;
+export default SidebarActionTrigger;

package/dist/places/components/layout/SidebarHeader.d.ts

@@ -0,0 +1,5 @@
+export interface SidebarHeaderProps {
+    open: boolean;
+    appName?: string;
+}
+export declare function SidebarHeader({ open, appName }: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/layout/SidebarLogo.d.ts

@@ -0,0 +1,5 @@
+interface SidebarLogoProps {
+    appName?: string;
+}
+export declare function SidebarLogo({ appName }: SidebarLogoProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/places/components/layout/sidebar-utils.d.ts

@@ -0,0 +1,12 @@
+export declare const SIDEBAR_PINNED_KEY = "forlogic-sidebar-pinned";
+export declare const getSidebarPinnedPreference: () => boolean;
+export declare const setSidebarPinnedPreference: (isPinned: boolean) => void;
+export declare const getColorVariant: (index: number) => string;
+interface Module {
+    id: string;
+    name: string;
+    url?: string;
+    status: 'active' | 'inactive';
+}
+export declare const handleModuleClick: (modules: Module[] | undefined, moduleUrl: string) => void;
+export {};

package/dist/places/components/modules/AccessDeniedDialog.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from "react";
+import { Module } from "./types";
+export interface AccessDeniedUnit {
+    alias: string;
+    name: string;
+}
+export interface AccessDeniedDialogProps {
+    open: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Callback ao clicar em módulo no grid */
+    onModuleClick?: (module: Module) => void;
+    /** Lista de nomes de módulos contratados */
+    contractedModules?: string[];
+    /** Callback quando usuário mostra interesse em módulo não contratado */
+    onModuleInterest?: (module: Module) => void;
+    /** Nome do usuário logado */
+    userName?: string;
+    /** Nome da unidade atual */
+    unitName?: string;
+    /** Lista de unidades disponíveis */
+    units?: AccessDeniedUnit[];
+    /** Alias da unidade atual */
+    currentAlias?: string;
+    /** Callback ao trocar de unidade */
+    onUnitChange?: (unit: AccessDeniedUnit) => void;
+    /** Callback ao fazer logout */
+    onLogout?: () => void;
+    /** URL do Forlogic Educa */
+    educaUrl?: string;
+    /** URL do Saber Gestão */
+    saberGestaoUrl?: string;
+    /** URL da Wiki */
+    wikiUrl?: string;
+    /** Se true, impede fechar o dialog (padrão: true) */
+    blocking?: boolean;
+    /** Tamanho do dialog (padrão: "lg") */
+    size?: "sm" | "md" | "lg";
+    /** Conteúdo customizado que substitui o ModulesContent (grid de módulos). Header e footer são mantidos. */
+    children?: ReactNode;
+    /** Identificador do módulo de origem. Usado em analytics. */
+    sourceModule?: string;
+}
+export declare function AccessDeniedDialog({ open, onOpenChange, onModuleClick, contractedModules, onModuleInterest, userName, unitName, units, currentAlias, onUnitChange, onLogout, educaUrl, saberGestaoUrl, wikiUrl, blocking, size, children, sourceModule, }: AccessDeniedDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/modules/ModuleAccessGuard.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode } from "react";
+import { Module } from "./types";
+export interface ModuleAccessGuardProps {
+    children: ReactNode;
+    /** Lista de nomes de módulos contratados */
+    contractedModules?: string[];
+    /** Callback ao clicar em módulo no grid */
+    onModuleClick?: (module: Module) => void;
+    /** Callback quando usuário mostra interesse em módulo não contratado */
+    onModuleInterest?: (module: Module) => void;
+    /** URL do Forlogic Educa */
+    educaUrl?: string;
+    /** URL do Saber Gestão */
+    saberGestaoUrl?: string;
+    /** URL da Wiki */
+    wikiUrl?: string;
+    /**
+     * Rotas que ignoram o guard (bypass).
+     * Suporta glob simples com `*` no final: `/public/*` faz match com `/public/qualquer-coisa`.
+     * Sem `bypassPaths` → comportamento padrão (todas as rotas protegidas).
+     */
+    bypassPaths?: string[];
+    /**
+     * Mapa declarativo de rotas → conteúdo customizado no dialog de acesso negado.
+     * As chaves são paths (suportam glob com `*` no final).
+     * Se a rota atual faz match, o conteúdo substitui o grid de módulos.
+     * Se nenhuma rota faz match → grid padrão.
+     *
+     * Defina em arquivo separado para manter o App.tsx limpo:
+     * ```tsx
+     * // src/config/accessDeniedRoutes.tsx
+     * export const accessDeniedRoutes = {
+     *   '/docs/matrix-link': <ModuleOfferContent title={t('know_staff')} ... />,
+     *   '/reports/*': <ModuleOfferContent title="Relatórios" ... />,
+     * };
+     * ```
+     */
+    accessDeniedRoutes?: Record<string, ReactNode>;
+    /** Identificador do módulo de origem. Usado em analytics. */
+    sourceModule?: string;
+}
+export declare function ModuleAccessGuard({ children, contractedModules, onModuleClick, onModuleInterest, educaUrl, saberGestaoUrl, wikiUrl, bypassPaths, accessDeniedRoutes, sourceModule, }: ModuleAccessGuardProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/modules/ModuleGrid.d.ts

@@ -0,0 +1,9 @@
+import { Module } from "./types";
+interface ModuleGridProps {
+    modules: Module[];
+    onModuleClick?: (module: Module) => void;
+    contractedModules?: string[];
+    onModuleInterest?: (module: Module) => void;
+}
+export declare function ModuleGrid({ modules, onModuleClick, contractedModules, onModuleInterest, }: ModuleGridProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/places/components/modules/ModuleOfferContent.d.ts

@@ -0,0 +1,20 @@
+import React, { ReactNode } from "react";
+export interface ModuleOfferContentProps {
+    /** Título da oferta — ex: "Conheça o módulo Educação, da suíte SABER." */
+    title: string;
+    /** Descrição da oferta */
+    description: string;
+    /** URL de imagem/ilustração */
+    image?: string;
+    /** Ícone alternativo à imagem */
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    /** Texto do botão CTA */
+    ctaLabel?: string;
+    /** Ação do botão CTA */
+    onCtaClick?: () => void;
+    /** Conteúdo 100% livre — substitui image + CTA quando fornecido */
+    children?: ReactNode;
+}
+export declare function ModuleOfferContent({ title, description, image, icon: Icon, ctaLabel, onCtaClick, children, }: ModuleOfferContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/modules/ModulesContent.d.ts

@@ -0,0 +1,21 @@
+import { Module } from "./types";
+export interface ModulesContentProps {
+    onModuleClick?: (module: Module) => void;
+    /** Lista de nomes de módulos contratados. Se não fornecido, todos aparecem como contratados. */
+    contractedModules?: string[];
+    /** Callback quando usuário mostra interesse em módulo não contratado */
+    onModuleInterest?: (module: Module) => void;
+    /** URL para redirecionar quando clicar em módulo não contratado */
+    nonContractedUrl?: string;
+    /** URL do Forlogic Educa (suporta placeholder {alias}) */
+    educaUrl?: string;
+    /** URL do Saber Gestão */
+    saberGestaoUrl?: string;
+    /** URL da Wiki */
+    wikiUrl?: string;
+    /** Alias ativo para resolver placeholders {alias} nas URLs */
+    alias?: string;
+    /** Identificador do módulo de origem (de onde o menu foi aberto). Usado em analytics. */
+    sourceModule?: string;
+}
+export declare function ModulesContent({ onModuleClick, contractedModules, onModuleInterest, nonContractedUrl, educaUrl, saberGestaoUrl, wikiUrl, alias, sourceModule, }: ModulesContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/modules/ModulesDialog.d.ts

@@ -0,0 +1,3 @@
+import { ModulesDialogProps } from "./types";
+export declare function ModulesDialog({ open, onOpenChange, onModuleClick, contractedModules, onModuleInterest, educaUrl, saberGestaoUrl, wikiUrl, sourceModule, }: ModulesDialogProps): import("react/jsx-runtime").JSX.Element;
+export default ModulesDialog;

package/dist/places/components/modules/ModulesFooterCards.d.ts

@@ -0,0 +1,10 @@
+export interface ModulesFooterCardsProps {
+    educaUrl?: string;
+    saberGestaoUrl?: string;
+    wikiUrl?: string;
+    /** Alias ativo para resolver placeholders {alias} nas URLs */
+    alias?: string;
+    /** Identificador do módulo de origem. Usado em analytics. */
+    sourceModule?: string;
+}
+export declare function ModulesFooterCards({ educaUrl, saberGestaoUrl, wikiUrl, alias, sourceModule, }: ModulesFooterCardsProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/modules/icons/ModulesCardIcons.d.ts

@@ -0,0 +1,19 @@
+interface IconProps {
+    className?: string;
+}
+/**
+ * Ícone outline do Qualiex para marca d'água
+ * Usado no card t('learn_qualiex')
+ */
+export declare function QualiexOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Ícone outline do Saber Gestão para marca d'água
+ * Usado no card t('know_saber_gestao')
+ */
+export declare function SaberGestaoOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Ícone de livro/wiki para marca d'água
+ * Usado no card "Dúvidas sobre os módulos?"
+ */
+export declare function WikiOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/places/components/modules/index.d.ts

@@ -0,0 +1,14 @@
+export { ModulesDialog } from './ModulesDialog';
+export { ModulesContent } from './ModulesContent';
+export { ModuleGrid } from './ModuleGrid';
+export { ModuleAccessGuard } from './ModuleAccessGuard';
+export { AccessDeniedDialog } from './AccessDeniedDialog';
+export { ModuleOfferContent } from './ModuleOfferContent';
+export { ModulesFooterCards } from './ModulesFooterCards';
+export { MODULES_DATA } from './modulesData';
+export type { ModulesDialogProps, Module, ModuleGroup } from './types';
+export type { ModulesContentProps } from './ModulesContent';
+export type { ModuleAccessGuardProps } from './ModuleAccessGuard';
+export type { AccessDeniedDialogProps, AccessDeniedUnit } from './AccessDeniedDialog';
+export type { ModuleOfferContentProps } from './ModuleOfferContent';
+export type { ModulesFooterCardsProps } from './ModulesFooterCards';

package/dist/places/components/modules/modulesData.d.ts

@@ -0,0 +1,6 @@
+import { ModuleGroup } from "./types";
+/**
+ * Dados dos módulos organizados por grupo.
+ * Cores no formato 'bg-[#HEX]' para cores precisas baseadas no design.
+ */
+export declare const MODULES_DATA: ModuleGroup[];

package/dist/places/components/modules/types.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { OnboardingStep } from "../ui/onboarding-dialog";
+export interface Module {
+    name: string;
+    description?: string;
+    color: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    url?: string;
+    /** Alias do software no SOFTWARES_MAP para mapeamento dinâmico de contratação */
+    softwareAlias?: string;
+    /** Steps do onboarding para módulos não contratados */
+    onboardingSteps?: OnboardingStep[];
+}
+export interface ModuleGroup {
+    id: string;
+    label: string;
+    modules: Module[];
+}
+export interface ModulesDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onModuleClick?: (module: Module) => void;
+    /** Lista de nomes de módulos contratados. Se não fornecido, todos aparecem como contratados. */
+    contractedModules?: string[];
+    /** Callback quando usuário mostra interesse em módulo não contratado (após onboarding) */
+    onModuleInterest?: (module: Module) => void;
+    /** URL para redirecionar quando clicar em módulo não contratado */
+    nonContractedUrl?: string;
+    /** URL do Forlogic Educa (suporta placeholder {alias}) */
+    educaUrl?: string;
+    /** URL do Saber Gestão */
+    saberGestaoUrl?: string;
+    /** @deprecated Use educaUrl. URL da wiki (mantido para compatibilidade) */
+    wikiUrl?: string;
+    /** @deprecated Não mais utilizado no novo layout */
+    allModulesUrl?: string;
+    /** Identificador do módulo de origem (de onde o menu foi aberto). Usado em analytics. */
+    sourceModule?: string;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * @module Accordion
+ * Acordeão expansível. Composição: `Accordion` (raiz, com `type="single"` ou `"multiple"`)
+ * + `AccordionItem` (um por seção, requer `value`) + `AccordionTrigger` + `AccordionContent`.
+ *
+ * @example
+ * ```tsx
+ * <Accordion type="single" collapsible>
+ *   <AccordionItem value="item-1">
+ *     <AccordionTrigger>Termos</AccordionTrigger>
+ *     <AccordionContent>Conteúdo expansível...</AccordionContent>
+ *   </AccordionItem>
+ * </Accordion>
+ * ```
+ */
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+/**
+ * Componente `Accordion` da lib.
+ * @example
+ * <Accordion />
+ */
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `AccordionItem` da lib.
+ * @example
+ * <AccordionItem />
+ */
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Componente `AccordionTrigger` da lib.
+ * @example
+ * <AccordionTrigger />
+ */
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Componente `AccordionContent` da lib.
+ * @example
+ * <AccordionContent />
+ */
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

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

@@ -0,0 +1,48 @@
+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'];
+}
+/**
+ * Botão estilizado para ações em tabelas e menus
+ *
+ * Botão pequeno otimizado para actions em linhas de tabela, com estilo
+ * consistente usando cores do tema (primary).
+ *
+ * **Características:**
+ * - Tamanho compacto (height: 28px, padding: 8px)
+ * - Ícone padrão: três pontos verticais (EllipsisVertical)
+ * - Estilo padrão: fundo azul claro (bg-primary/10), hover com primary/20
+ * - Variante action-secondary disponível para contextos secundários
+ * - Perfeito para menus de ação em linhas de tabela
+ *
+ * @example
+ * ```typescript
+ * import { ActionButton } from 'forlogic-core';
+ *
+ * // Botão de ações com ícone padrão (três pontos)
+ * <ActionButton onClick={() => setMenuOpen(true)} />
+ *
+ * // Botão customizado com ícone próprio
+ * <ActionButton>
+ *   <Edit size={12} />
+ * </ActionButton>
+ *
+ * // Variante secundária
+ * <ActionButton variant="action-secondary">
+ *   <LayoutGrid size={12} />
+ * </ActionButton>
+ * ```
+ *
+ * @param props.children Conteúdo customizado (default: ícone de três pontos)
+ * @param props.variant Variante do botão (default: "action")
+ * @param props.className Classes CSS adicionais
+ */
+export declare const ActionButton: React.ForwardRefExoticComponent<ActionButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

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

@@ -0,0 +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/places/components/ui/alert.d.ts

@@ -0,0 +1,44 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+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 };