@celke/kole-react 0.0.0-stage → 0.1.0

package/dist/components/Botao/Botao.d.ts

@@ -0,0 +1,40 @@
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export type SeveridadeBotao = 'pri' | 'secundario' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'escuro';
+/**
+ * `solido` · `contorno` · `texto` · `suave` = fundo claro da cor · `gradiente`
+ * · `fantasma` = contorno discreto que se preenche no hover.
+ */
+export type AparenciaBotao = 'solido' | 'contorno' | 'texto' | 'suave' | 'gradiente' | 'fantasma';
+/** Padrões que um grupo (`GrupoBotoes`) repassa aos botões de dentro. */
+export interface PadroesBotao {
+    severidade?: SeveridadeBotao;
+    aparencia?: AparenciaBotao;
+    formato?: 'pilula' | 'retangulo';
+    tamanho?: 'pequeno' | 'medio' | 'grande';
+}
+export declare const PadroesBotaoCtx: import("react").Context<PadroesBotao>;
+export interface BotaoProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    rotulo?: string;
+    icone?: IconeProp;
+    posicaoIcone?: 'esquerda' | 'direita';
+    severidade?: SeveridadeBotao;
+    aparencia?: AparenciaBotao;
+    /** Mostra spinner e recusa o clique (o botão segue focável). */
+    carregando?: boolean;
+    /** Ocupa 100% da largura. */
+    bloco?: boolean;
+    /** `pilula` (padrão) · `retangulo` = cantos levemente arredondados. */
+    formato?: 'pilula' | 'retangulo';
+    tamanho?: 'pequeno' | 'medio' | 'grande';
+    /** Sombra fixa, ou `elevado` (sombra da cor que sobe no hover). */
+    sombra?: 'pequena' | 'media' | 'grande' | 'elevado';
+    /** Ícone num segmento mais escuro, colado à borda ("botão com rótulo"). */
+    iconeDestacado?: boolean;
+    /** Botão de alternância: liga/desliga (vira `aria-pressed`). */
+    pressionado?: boolean;
+    /** Balão de dica — use em botões só com ícone. */
+    dica?: string;
+    children?: ReactNode;
+}
+export declare const Botao: import("react").ForwardRefExoticComponent<BotaoProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/BotaoFechar/BotaoFechar.d.ts

@@ -0,0 +1,10 @@
+import type { ButtonHTMLAttributes } from 'react';
+export interface BotaoFecharProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** `claro` = para fundos escuros. */
+    variante?: 'padrao' | 'claro';
+    tamanho?: 'pequeno' | 'medio';
+    /** Nome para leitor de tela (padrão: "Fechar"). */
+    rotulo?: string;
+}
+/** O × de fechar (avisos, diálogos, painéis), com o nome acessível. */
+export declare function BotaoFechar({ variante, tamanho, rotulo, className, type, ...resto }: BotaoFecharProps): import("react").JSX.Element;

package/dist/components/Busca/Busca.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export interface ItemBusca {
+    rotulo: string;
+    rota: string;
+    icone?: IconeProp;
+    /** Caminho no menu (ex.: "Cadastros › Pessoas"). */
+    trilha?: string;
+}
+export interface BuscaProps {
+    placeholder?: string;
+    /** Mostra spinner no lugar da lupa. */
+    ocupado?: boolean;
+    /** Itens de menu filtrados pelo termo (seção "Menu" do painel). */
+    itensMenu?: ItemBusca[];
+    aoNavegar?: (rota: string) => void;
+    /** Enter sem item de menu ativo. */
+    aoBuscar?: (termo: string) => void;
+    aoMudarTermo?: (termo: string) => void;
+    /** Ctrl+K / ⌘K foca a busca (padrão: sim). */
+    atalho?: boolean;
+    /** Resultados do app no painel; marque opções navegáveis com `data-busca-opcao`. */
+    children?: ReactNode;
+    className?: string;
+}
+/** Busca global da topbar: filtra o menu e hospeda resultados do app. */
+export declare function Busca({ placeholder, ocupado, itensMenu, aoNavegar, aoBuscar, aoMudarTermo, atalho, children, className, }: BuscaProps): import("react").JSX.Element;

package/dist/components/CabecalhoPagina/CabecalhoPagina.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+import { type ItemTrilha } from '../Trilha/Trilha.js';
+export interface CabecalhoPaginaProps {
+    titulo: string;
+    icone?: IconeProp;
+    /** Linha pequena em caixa alta acima do título. */
+    categoria?: string;
+    /**
+     * Trilha de navegação logo abaixo do título. `true` = caminho automático do
+     * menu (via `Estrutura`); lista = automático + estes passos no fim (ex.: o
+     * registro aberto).
+     */
+    trilha?: boolean | ItemTrilha[];
+    /** Botões à direita do título. */
+    acoes?: ReactNode;
+    /** Texto descritivo abaixo. */
+    children?: ReactNode;
+    className?: string;
+}
+export declare function CabecalhoPagina({ titulo, icone, categoria, trilha, acoes, children, className }: CabecalhoPaginaProps): import("react").JSX.Element;

package/dist/components/Campo/Campo.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from 'react';
+/** Props comuns a todo campo de formulário. */
+export interface CampoBaseProps {
+    rotulo?: string;
+    /** Texto de ajuda abaixo do campo. */
+    dica?: string;
+    /** Mensagem de erro (pinta o campo de vermelho). */
+    erro?: string;
+    /** Aviso não-bloqueante (âmbar). */
+    aviso?: string;
+    obrigatorio?: boolean;
+    /** `campo` = rótulo em cima · `inline` = pílula com rótulo dentro (barras de filtro). */
+    variante?: 'campo' | 'inline';
+    className?: string;
+}
+export interface CampoProps extends CampoBaseProps {
+    htmlFor?: string;
+    msgId?: string;
+    children: ReactNode;
+}
+/**
+ * Contador de "tentativas de salvar" do formulário em volta. O `Form` o
+ * incrementa a cada envio; acima de zero, todo campo revela sua pendência
+ * mesmo sem ter sido tocado.
+ */
+export declare const RevelarCamposCtx: import("react").Context<number>;
+export declare const MSG_OBRIGATORIO = "Campo obrigat\u00F3rio";
+interface OpcoesValidacao {
+    valor: string;
+    /** Regra de formato do campo: mensagem, ou `''` se válido. */
+    validar?: (valor: string) => string;
+    obrigatorio?: boolean;
+    /** Erro vindo do app — sempre vence. */
+    erro?: string;
+    aviso?: string;
+}
+/**
+ * Regra de exibição de pendência:
+ * - o erro só aparece ao SAIR do campo depois de o usuário mexer nele, ou
+ *   quando o formulário tenta salvar;
+ * - um valor recebido de fora (carga de registro) que não atende ao formato
+ *   NÃO é reformatado nem recusado: vira aviso âmbar não bloqueante.
+ */
+export declare function useValidacaoCampo({ valor, validar, obrigatorio, erro, aviso }: OpcoesValidacao): {
+    erro: string | undefined;
+    aviso: string | undefined;
+    /** Chame no evento de digitação/gesto real do usuário. */
+    aoInteragir: () => void;
+    /** Chame no blur do controle. */
+    aoSair: () => false | void;
+};
+/** Ids estáveis do campo e da mensagem associada (aria-describedby). */
+export declare function useCampoIds(idExterno?: string): {
+    id: string;
+    msgId: string;
+};
+export declare function descricaoDe(p: Pick<CampoBaseProps, 'erro' | 'aviso' | 'dica'>, msgId: string): string | undefined;
+/**
+ * Moldura de campo: rótulo, asterisco de obrigatório, erro/aviso/dica.
+ * Envolve qualquer controle — os campos da biblioteca já a usam por dentro.
+ */
+export declare function Campo({ rotulo, dica, erro, aviso, obrigatorio, variante, className, htmlFor, msgId, children, }: CampoProps): import("react").JSX.Element;
+export {};

package/dist/components/CampoBusca/CampoBusca.d.ts

@@ -0,0 +1,28 @@
+import { type Key } from 'react';
+import { type CampoBaseProps } from '../Campo/Campo.js';
+export interface CampoBuscaProps<T> extends CampoBaseProps {
+    /** A busca do módulo: termo → registros. */
+    buscar: (termo: string) => Promise<T[]>;
+    /** Texto do registro (no campo e em cada linha do painel). */
+    paraRotulo: (item: T) => string;
+    /** Linha secundária opcional no painel (ex.: CPF, lotação). */
+    paraDetalhe?: (item: T) => string | undefined;
+    /** Chave de cada resultado (padrão: `item.id` ou o rótulo). */
+    chave?: (item: T) => Key;
+    /** O REGISTRO escolhido — texto digitado sem escolha não é valor. */
+    valor?: T | null;
+    aoMudar?: (valor: T | null) => void;
+    /** Mínimo de caracteres para buscar (padrão: 1). */
+    minimo?: number;
+    atraso?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    id?: string;
+    /** Mensagem quando a busca não acha nada. */
+    vazioTexto?: string;
+}
+/**
+ * Autocompletar com busca no servidor: o jeito canônico de buscar e vincular
+ * uma entidade (pessoa, servidor, fornecedor…) grande demais para carregar inteira.
+ */
+export declare function CampoBusca<T>({ rotulo, dica, erro, aviso, obrigatorio, variante, className, id: idExterno, buscar, paraRotulo, paraDetalhe, chave, valor, aoMudar, minimo, atraso, placeholder, disabled, vazioTexto, }: CampoBuscaProps<T>): import("react").JSX.Element;

package/dist/components/CampoBusca/CampoCidade.d.ts

@@ -0,0 +1,25 @@
+import type { CampoBaseProps } from '../Campo/Campo.js';
+export interface Municipio {
+    id: string | number;
+    nome: string;
+}
+export interface CampoCidadeProps extends CampoBaseProps {
+    /** UF que filtra os municípios (`''` = nenhuma). Trocar de UF limpa a cidade. */
+    uf: string;
+    /**
+     * Municípios da UF. Sem esta função o campo vira texto livre
+     * (continua utilizável, só não sugere).
+     */
+    buscarPorUf?: (uf: string) => Promise<Municipio[]>;
+    /** O município escolhido — ou o texto digitado, no modo texto livre. */
+    valor?: Municipio | string | null;
+    aoMudar?: (valor: Municipio | string | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    id?: string;
+}
+/**
+ * Município filtrado pela UF, com a cascata UF → cidade embutida: quando a
+ * UF muda, a cidade da UF anterior é limpa pelo próprio campo.
+ */
+export declare function CampoCidade({ uf, buscarPorUf, valor, aoMudar, placeholder, disabled, ...p }: CampoCidadeProps): import("react").JSX.Element;

package/dist/components/CampoDominio/CampoDominio.d.ts

@@ -0,0 +1,17 @@
+import { type CampoSelectMultiploProps, type CampoSelectProps } from '../CampoSelect/CampoSelect.js';
+type SemOpcoes<P> = Omit<P, 'opcoes'>;
+export interface CampoUfProps extends SemOpcoes<CampoSelectProps<string>> {
+    /** `sigla` = "PR" · `completo` = "PR — Paraná" (padrão). */
+    exibicao?: 'sigla' | 'completo';
+}
+/** UF (estado) a partir de `ESTADOS`; o valor é a sigla. */
+export declare function CampoUf({ exibicao, comBusca, placeholder, ...p }: CampoUfProps): import("react").JSX.Element;
+export interface CampoUfMultiploProps extends SemOpcoes<CampoSelectMultiploProps<string>> {
+    exibicao?: 'sigla' | 'completo';
+}
+/** Várias UFs; o valor é a lista de siglas. */
+export declare function CampoUfMultiplo({ exibicao, comBusca, placeholder, ...p }: CampoUfMultiploProps): import("react").JSX.Element;
+export type CampoTipoPessoaProps = SemOpcoes<CampoSelectProps<'F' | 'J'>>;
+/** Pessoa física (`F`) ou jurídica (`J`). */
+export declare function CampoTipoPessoa({ placeholder, ...p }: CampoTipoPessoaProps): import("react").JSX.Element;
+export {};

package/dist/components/CampoMarcacao/CampoMarcacao.d.ts

@@ -0,0 +1,13 @@
+import type { InputHTMLAttributes } from 'react';
+export interface CampoMarcacaoProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'checked' | 'defaultChecked' | 'className' | 'value'> {
+    rotulo?: string;
+    valor?: boolean;
+    aoMudar?: (valor: boolean) => void;
+    /** `caixa` = checkbox · `chave` = interruptor (switch). */
+    aparencia?: 'caixa' | 'chave';
+    dica?: string;
+    erro?: string;
+    obrigatorio?: boolean;
+    className?: string;
+}
+export declare function CampoMarcacao({ rotulo, valor, aoMudar, aparencia, dica, erro, obrigatorio, className, id: idExterno, onChange, ...resto }: CampoMarcacaoProps): import("react").JSX.Element;

package/dist/components/CampoMensagem/CampoMensagem.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+export interface CampoMensagemProps {
+    valor: string;
+    aoMudar: (valor: string) => void;
+    /** Recebe o texto sem espaços nas pontas; nunca é chamado com texto vazio. */
+    aoEnviar: (texto: string) => void;
+    /** Uma resposta está chegando: o Enviar vira Parar. */
+    gerando?: boolean;
+    /** Chamado pelo botão Parar (sem ele, o Parar fica desabilitado). */
+    aoParar?: () => void;
+    desabilitado?: boolean;
+    placeholder?: string;
+    /** Limite de caracteres; o contador aparece perto do limite. */
+    maxCaracteres?: number;
+    /** Até quantas linhas o campo cresce antes de rolar. */
+    linhasMaximas?: number;
+    autoFocus?: boolean;
+    /** Botões próprios do app à esquerda do Enviar (anexar, escolher documentos…). */
+    acoesExtras?: ReactNode;
+    /** Rótulo do campo para leitores de tela. */
+    rotulo?: string;
+    rotuloEnviar?: string;
+    rotuloParar?: string;
+    id?: string;
+    className?: string;
+}
+/**
+ * Campo de envio de mensagem: Enter envia, Shift+Enter quebra a linha. Cresce
+ * com o texto até `linhasMaximas` e depois rola.
+ */
+export declare const CampoMensagem: import("react").ForwardRefExoticComponent<CampoMensagemProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/dist/components/CampoSelect/CampoSelect.d.ts

@@ -0,0 +1,25 @@
+import type { Opcao } from '../../utils/tipos.js';
+import { type CampoBaseProps } from '../Campo/Campo.js';
+interface BaseSelectProps<V> extends CampoBaseProps {
+    opcoes: Opcao<V>[];
+    placeholder?: string;
+    /** Digitar filtra as opções. */
+    comBusca?: boolean;
+    /** Mostra o "×" para limpar quando há valor. */
+    botaoLimpar?: boolean;
+    disabled?: boolean;
+    id?: string;
+}
+export interface CampoSelectProps<V = string> extends BaseSelectProps<V> {
+    valor?: V | null;
+    aoMudar?: (valor: V | null) => void;
+}
+export interface CampoSelectMultiploProps<V = string> extends BaseSelectProps<V> {
+    valor?: V[];
+    aoMudar?: (valor: V[]) => void;
+}
+/** Select de opção única. */
+export declare function CampoSelect<V = string>({ valor, aoMudar, ...p }: CampoSelectProps<V>): import("react").JSX.Element;
+/** Select de várias opções (com caixas de marcação). */
+export declare function CampoSelectMultiplo<V = string>({ valor, aoMudar, ...p }: CampoSelectMultiploProps<V>): import("react").JSX.Element;
+export {};

package/dist/components/CampoSenha/CampoSenha.d.ts

@@ -0,0 +1,16 @@
+import { type PoliticaSenha } from '../../utils/senha.js';
+import { type CampoTextoProps } from '../CampoTexto/CampoTexto.js';
+export interface CampoSenhaProps extends Omit<CampoTextoProps, 'type' | 'mascara' | 'maiuscula' | 'prefixo' | 'sufixo'> {
+    /** Botão de olho para mostrar/ocultar (padrão: sim). */
+    revelavel?: boolean;
+    /**
+     * Liga o medidor de força E a validação pela `politica`. Desligado no
+     * login — não se cobra política de uma senha que já existe.
+     */
+    forca?: boolean;
+    politica?: PoliticaSenha;
+    /** `new-password` em cadastro/troca de senha (padrão: `current-password`). */
+    autoComplete?: string;
+}
+/** Senha com olho, aviso de Caps Lock e medidor de força opcional. */
+export declare function CampoSenha({ revelavel, forca, politica, autoComplete, className, valor, validar, aviso, onKeyDown, onKeyUp, disabled, ...p }: CampoSenhaProps): import("react").JSX.Element;

package/dist/components/CampoTextarea/CampoTextarea.d.ts

@@ -0,0 +1,11 @@
+import { type TextareaHTMLAttributes } from 'react';
+import { type CampoBaseProps } from '../Campo/Campo.js';
+type TextareaNativo = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'value' | 'className'>;
+export interface CampoTextareaProps extends Omit<CampoBaseProps, 'variante'>, TextareaNativo {
+    valor?: string;
+    aoMudar?: (valor: string) => void;
+    /** Com `maxLength`, mostra o contador `n/máx` no canto. */
+    contador?: boolean;
+}
+export declare const CampoTextarea: import("react").ForwardRefExoticComponent<CampoTextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/components/CampoTexto/CampoTexto.d.ts

@@ -0,0 +1,63 @@
+import { type InputHTMLAttributes, type ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+import { type Mascara } from '../../utils/mascara.js';
+import { type CampoBaseProps } from '../Campo/Campo.js';
+type InputNativo = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'className'>;
+export interface CampoTextoProps extends CampoBaseProps, InputNativo {
+    valor?: string;
+    aoMudar?: (valor: string) => void;
+    /** Ícone à esquerda, dentro do campo. */
+    icone?: IconeProp;
+    /** Máscara de digitação (`0` dígito, `A` letra, `S` alfanumérico). */
+    mascara?: Mascara;
+    /** Converte o texto para CAIXA ALTA enquanto digita. */
+    maiuscula?: boolean;
+    /** Texto fixo antes do valor (ex.: "R$"). */
+    prefixo?: ReactNode;
+    /** Conteúdo após o valor (ex.: botão de lupa). */
+    sufixo?: ReactNode;
+    /**
+     * Regra de formato: devolve a mensagem, ou `''` se válido. O erro aparece
+     * ao sair do campo depois de digitar (ou ao salvar o `Form`).
+     */
+    validar?: (valor: string) => string;
+}
+export declare const CampoTexto: import("react").ForwardRefExoticComponent<CampoTextoProps & import("react").RefAttributes<HTMLInputElement>>;
+type Preset = Omit<CampoTextoProps, 'mascara'>;
+export declare const CampoCpf: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+export declare const CampoCnpj: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** CPF ou CNPJ: a máscara muda pelo número de dígitos. */
+export declare const CampoCpfCnpj: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+export declare const CampoCep: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+export declare const CampoPlaca: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+export declare const CampoEmail: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** RENAVAM: 9 a 11 dígitos. */
+export declare const CampoRenavam: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** Chassi (VIN): 17 caracteres, sem I, O e Q. */
+export declare const CampoChassi: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** CNH com dígitos verificadores do DENATRAN. */
+export declare const CampoCnh: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** IMEI com verificação de Luhn. */
+export declare const CampoImei: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+export interface CampoTelefoneProps extends Preset {
+    /** Restringe a fixo (10 dígitos) ou celular (11). Sem `tipo`, aceita os dois. */
+    tipo?: 'fixo' | 'celular';
+}
+export declare const CampoTelefone: import("react").ForwardRefExoticComponent<CampoTelefoneProps & import("react").RefAttributes<HTMLInputElement>>;
+/** Data no formato ISO (`AAAA-MM-DD`), com o seletor nativo do navegador. */
+export declare const CampoData: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** Hora `HH:MM`. */
+export declare const CampoHora: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** Data e hora `AAAA-MM-DDTHH:MM`. */
+export declare const CampoDataHora: import("react").ForwardRefExoticComponent<Preset & import("react").RefAttributes<HTMLInputElement>>;
+/** Valor em reais: digita-se da direita (centavos primeiro), como no caixa. */
+export declare const CampoMoeda: import("react").ForwardRefExoticComponent<Omit<CampoTextoProps, "valor" | "aoMudar" | "mascara"> & {
+    valor?: number | null;
+    aoMudar?: (valor: number | null) => void;
+} & import("react").RefAttributes<HTMLInputElement>>;
+/** Número inteiro (só dígitos). */
+export declare const CampoInteiro: import("react").ForwardRefExoticComponent<Omit<CampoTextoProps, "valor" | "aoMudar" | "mascara"> & {
+    valor?: number | null;
+    aoMudar?: (valor: number | null) => void;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export {};

package/dist/components/Card/Card.d.ts

@@ -0,0 +1,51 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import type { Severidade } from '../../utils/tipos.js';
+/** Mesmas cores do `Alerta`/`Badge`. */
+export type CorCard = Severidade | 'pri' | 'destaque';
+export interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onClick' | 'title'> {
+    /** Capa que sangra até a borda (imagem, mapa…). */
+    midia?: ReactNode;
+    /**
+     * Onde fica a mídia: `topo` (padrão) · `base` · `esquerda`/`direita`
+     * (card horizontal) · `fundo` (texto sobre a imagem, com véu escuro).
+     */
+    posicaoMidia?: 'topo' | 'base' | 'esquerda' | 'direita' | 'fundo';
+    /** Título do cabeçalho (com linha embaixo). */
+    titulo?: ReactNode;
+    subtitulo?: ReactNode;
+    /** Conteúdo à direita do título (botões, badge). */
+    ferramentas?: ReactNode;
+    /** Botão de recolher/expandir o corpo no cabeçalho. */
+    recolhivel?: boolean;
+    /** Começa recolhido (com `recolhivel`). */
+    recolhidoInicial?: boolean;
+    /** Botão de fechar no cabeçalho: o card sai da tela. */
+    dispensavel?: boolean;
+    aoFechar?: () => void;
+    /** Botão que abre o card em tela cheia (Esc volta). */
+    telaCheia?: boolean;
+    /** Ações flutuantes no canto superior direito (aparecem no hover). */
+    acoes?: ReactNode;
+    rodape?: ReactNode;
+    /** Fundo na cor (texto claro/escuro conforme o contraste). */
+    cor?: CorCard;
+    /** Borda na cor, fundo normal. */
+    borda?: CorCard;
+    alinhamento?: 'esquerda' | 'centro' | 'direita';
+    /** Corpo sem espaçamento interno (listas, tabelas, imagem inteira). */
+    corpoSemEspaco?: boolean;
+    /**
+     * Painel de leitura que COBRE o card ao passar o mouse ou focar (ex.: algumas
+     * linhas de `<Detalhes>`). Enriquecimento rápido, não substitui a ficha.
+     */
+    detalhes?: ReactNode;
+    /** Torna o card inteiro clicável (role=button + Enter/Espaço). */
+    aoClicar?: () => void;
+    children?: ReactNode;
+}
+export declare function Card({ midia, posicaoMidia, titulo, subtitulo, ferramentas, recolhivel, recolhidoInicial, dispensavel, aoFechar, telaCheia, acoes, rodape, cor, borda, alinhamento, corpoSemEspaco, detalhes, aoClicar, children, className, ...resto }: CardProps): import("react").JSX.Element | null;
+/** Cards colados lado a lado, com a mesma altura (vira coluna em tela estreita). */
+export declare function GrupoCards({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/Carregando/Carregando.d.ts

@@ -0,0 +1,10 @@
+export interface CarregandoProps {
+    mensagem?: string;
+    /** Imagem da marca (ex.: logo) no lugar do anel. */
+    logo?: string;
+    /** Cobre a página inteira com máscara e bloqueia interação. */
+    bloqueante?: boolean;
+    className?: string;
+}
+/** Indicador de espera de seção/página. Para listas, prefira Skeleton. */
+export declare function Carregando({ mensagem, logo, bloqueante, className }: CarregandoProps): import("react").JSX.Element;

package/dist/components/Carrossel/Carrossel.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+export interface SlideCarrossel {
+    imagem: string;
+    alt: string;
+    titulo?: ReactNode;
+    descricao?: ReactNode;
+    /** Tempo deste slide, em ms (sobrepõe o `intervalo` do carrossel). */
+    intervalo?: number;
+}
+export interface CarrosselProps {
+    slides: SlideCarrossel[];
+    /** Nome do carrossel para leitor de tela. */
+    rotulo: string;
+    /** Avança sozinho. Desligado para quem prefere menos movimento. */
+    automatico?: boolean;
+    /** Tempo de cada slide, em ms. */
+    intervalo?: number;
+    /** Setas de anterior/próximo. */
+    controles?: boolean;
+    /** Tracinhos que levam a cada slide. */
+    indicadores?: boolean;
+    /** `deslizar` (padrão) ou `esmaecer`. */
+    transicao?: 'deslizar' | 'esmaecer';
+    /** Controles e legendas escuros, para imagens claras. */
+    escuro?: boolean;
+    /** Arrastar para os lados no toque/mouse troca o slide. */
+    arrastar?: boolean;
+    /** Proporção da área (ex.: `'16 / 9'`). */
+    proporcao?: string;
+    className?: string;
+}
+/** Carrossel de imagens com legendas, setas, indicadores e avanço automático. */
+export declare function Carrossel({ slides, rotulo, automatico, intervalo, controles, indicadores, transicao, escuro, arrastar, proporcao, className, }: CarrosselProps): import("react").JSX.Element;

package/dist/components/Chip/Chip.d.ts

@@ -0,0 +1,11 @@
+export interface ChipProps {
+    rotulo: string;
+    /** Nome do que está etiquetado (ex.: "Protocolo" → PROTOCOLO: 123). */
+    campo?: string;
+    /** Mostra o "×" e dispara `aoRemover`. */
+    aoRemover?: () => void;
+    /** `false` tira o "×" da ordem do Tab (chips dentro de controles compostos). */
+    focavel?: boolean;
+    className?: string;
+}
+export declare function Chip({ rotulo, campo, aoRemover, focavel, className }: ChipProps): import("react").JSX.Element;

package/dist/components/Citacao/Citacao.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export type CorCitacao = 'pri' | 'secundario' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'escuro';
+export interface CitacaoProps {
+    /** O texto citado. */
+    children: ReactNode;
+    /** Quem disse. */
+    autor?: ReactNode;
+    /** De onde veio (livro, discurso…), em itálico depois do autor. */
+    fonte?: ReactNode;
+    cor?: CorCitacao;
+    /** `simples` = filete na lateral · `cartao` = fundo claro da cor, ícone e aspas. */
+    aparencia?: 'simples' | 'cartao';
+    alinhamento?: 'inicio' | 'centro' | 'fim';
+    /** Ícone no canto do cartão (só na aparência `cartao`). */
+    icone?: IconeProp;
+    className?: string;
+}
+/** Citação (blockquote) com autor e fonte. */
+export declare function Citacao({ children, autor, fonte, cor, aparencia, alinhamento, icone, className }: CitacaoProps): import("react").JSX.Element;

package/dist/components/Confirmacao/Confirmacao.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from 'react';
+import { type SeveridadeBotao } from '../Botao/Botao.js';
+export interface OpcoesConfirmacao {
+    titulo: string;
+    mensagem?: ReactNode;
+    severidade?: Exclude<SeveridadeBotao, 'secundario'>;
+    icone?: string;
+    rotuloAceitar?: string;
+    rotuloRecusar?: string;
+    iconeAceitar?: string;
+    /** Só o botão de OK (aviso). */
+    somenteOk?: boolean;
+}
+/** Remoção: sempre vermelha e com lixeira (não dá para trocar). */
+export type OpcoesRemocao = Omit<Partial<OpcoesConfirmacao>, 'severidade' | 'iconeAceitar' | 'somenteOk'>;
+/** Aviso: um botão só, para ciência. */
+export type OpcoesAviso = Omit<OpcoesConfirmacao, 'somenteOk' | 'rotuloRecusar'>;
+export interface Confirmar {
+    (opcoes: OpcoesConfirmacao): Promise<boolean>;
+    /** Atalho institucional de exclusão de dado salvo (irreversível). */
+    remover: (opcoes?: OpcoesRemocao) => Promise<boolean>;
+    /** Só ciência — "alertar" é `avisar({ severidade: 'err' })`. */
+    avisar: (opcoes: OpcoesAviso) => Promise<void>;
+}
+/** Fornece `useConfirmacao()` para a árvore. Já incluso no `ProvedorUi`. */
+export declare function ProvedorConfirmacao({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * `const confirmar = useConfirmacao();`
+ * `if (await confirmar({ titulo: 'Excluir?', severidade: 'err' })) …`
+ * `if (await confirmar.remover({ mensagem: '"TJ-PR 2026" será removido.' })) …`
+ * `await confirmar.avisar({ titulo: 'Prazo encerrado', severidade: 'warn' })`
+ */
+export declare function useConfirmacao(): Confirmar;

package/dist/components/Conversa/Conversa.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+export interface ConversaProps {
+    /** As mensagens (`Mensagem`), da mais antiga para a mais nova. */
+    children?: ReactNode;
+    /** Mostrado quando não há mensagens. Padrão: um `Vazio`. */
+    vazio?: ReactNode;
+    /** Campo de envio fixo abaixo da rolagem (normalmente um `CampoMensagem`). */
+    campo?: ReactNode;
+    /** Largura máxima das mensagens e do campo, centralizados (ex.: `48rem` numa página inteira). */
+    larguraMaxima?: string;
+    /** Nome da conversa para leitores de tela. */
+    rotulo?: string;
+    rotuloIrParaFim?: string;
+    className?: string;
+}
+/**
+ * Área rolável de uma conversa. Acompanha o fim quando chegam mensagens ou a
+ * última cresce (streaming); se a pessoa rolar para cima, para de puxar e
+ * mostra "Ir para o fim". Ocupa a altura do contêiner pai.
+ */
+export declare function Conversa({ children, vazio, campo, larguraMaxima, rotulo, rotuloIrParaFim, className, }: ConversaProps): import("react").JSX.Element;

package/dist/components/Detalhes/Detalhes.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export interface DetalhesProps {
+    rotulo: string;
+    /** Valor em texto; `children` substitui. Vazio mostra travessão. */
+    valor?: ReactNode;
+    /** `coluna` = rótulo em cima · `linha` = rótulo à esquerda, valor à direita. */
+    disposicao?: 'coluna' | 'linha';
+    children?: ReactNode;
+    className?: string;
+}
+/** Par rótulo/valor para telas de visualização. */
+export declare function Detalhes({ rotulo, valor, disposicao, children, className }: DetalhesProps): import("react").JSX.Element;