@celke/kole-react 0.0.0-stage → 0.2.0

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,12 @@
+export interface AvatarProps {
+    foto?: string;
+    /** Nome completo — gera as iniciais quando não há foto. */
+    nome?: string;
+    iniciais?: string;
+    tom?: 'claro' | 'escuro';
+    formato?: 'circulo' | 'quadrado';
+    /** Tamanho CSS (ex.: `2rem`). */
+    tamanho?: string;
+    className?: string;
+}
+export declare function Avatar({ foto, nome, iniciais, tom, formato, tamanho, className }: AvatarProps): import("react").JSX.Element;

package/dist/components/Badge/Badge.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+import type { Severidade } from '../../utils/tipos.js';
+/** Mesmas cores do `Alerta`: severidades + `pri` (azul) e `destaque` (laranja). */
+export type CorBadge = Severidade | 'pri' | 'destaque';
+export interface BadgeProps {
+    cor?: CorBadge;
+    /**
+     * `solido` (padrão) · `suave` = fundo claro · `contorno` = só a borda ·
+     * `gradiente` · `inverso` = fundo da superfície com texto colorido (para
+     * usar dentro de um botão sólido da mesma cor).
+     */
+    aparencia?: 'solido' | 'suave' | 'contorno' | 'gradiente' | 'inverso';
+    /** `pilula` = cantos totalmente arredondados. */
+    formato?: 'padrao' | 'pilula';
+    /** `herdar` = acompanha o tamanho do texto em volta (títulos). */
+    tamanho?: 'pequeno' | 'medio' | 'herdar';
+    icone?: IconeProp;
+    /** Texto do badge (ou use `children`). */
+    rotulo?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+/** Etiqueta curta: contagem, rótulo de novidade, categoria. */
+export declare function Badge({ cor, aparencia, formato, tamanho, icone, rotulo, children, className }: BadgeProps): import("react").JSX.Element;
+export interface ComBadgeProps {
+    /** Elemento que recebe o badge (avatar, botão, ícone). */
+    children: ReactNode;
+    /** Contagem ou texto no canto; com `ponto`, é ignorado. */
+    conteudo?: ReactNode;
+    /** Acima disto vira "N+" (só para números; padrão: 99). */
+    max?: number;
+    /** Só um ponto (ex.: "online", "não lido"). */
+    ponto?: boolean;
+    cor?: CorBadge;
+    /** Canto do badge (padrão: superior direito). */
+    posicao?: 'superior-direita' | 'inferior-direita' | 'superior-esquerda' | 'inferior-esquerda';
+    /** Texto para leitor de tela (ex.: "99 mensagens não lidas"). */
+    descricao?: string;
+    className?: string;
+}
+/** Posiciona um badge (ou ponto) no canto de outro elemento. */
+export declare function ComBadge({ children, conteudo, max, ponto, cor, posicao, descricao, className }: ComBadgeProps): import("react").JSX.Element;

package/dist/components/Balao/Balao.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from 'react';
+export type PosicaoBalao = 'cima' | 'direita' | 'baixo' | 'esquerda';
+export type CorBalao = 'pri' | 'secundario' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'escuro';
+/** `padrao` · `cabecalho` = só o título na cor · `solido` = balão todo na cor · `suave` = fundo claro da cor. */
+export type AparenciaBalao = 'padrao' | 'cabecalho' | 'solido' | 'suave';
+/**
+ * `clique` = abre/fecha no clique; fecha também ao clicar fora ou Esc ·
+ * `foco` = fecha no próximo clique em qualquer lugar · `passar` = abre com o
+ * mouse em cima ou com o foco do teclado.
+ */
+export type GatilhoBalao = 'clique' | 'foco' | 'passar';
+export interface BalaoProps {
+    /** O elemento que abre o balão (botão, ícone, avatar…). */
+    children: ReactNode;
+    titulo?: ReactNode;
+    conteudo: ReactNode;
+    /** Lado preferido; vira para o oposto se não couber. */
+    posicao?: PosicaoBalao;
+    cor?: CorBalao;
+    aparencia?: AparenciaBalao;
+    gatilho?: GatilhoBalao;
+    /** Largura máxima (padrão `17rem`). */
+    largura?: string;
+    className?: string;
+}
+/**
+ * Balão com título e conteúdo (popover), ancorado num elemento. Abre no
+ * clique, no foco ou ao passar o mouse; nas 4 direções e em cores.
+ */
+export declare function Balao({ children, titulo, conteudo, posicao, cor, aparencia, gatilho, largura, className, }: BalaoProps): import("react").JSX.Element;

package/dist/components/BoasVindas/BoasVindas.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+export interface BoasVindasProps {
+    /** Nome completo (a saudação usa primeiro + último). */
+    nome: string;
+    cargo?: string;
+    /** Sigla da unidade (ex.: RH). */
+    sigla?: string;
+    foto?: string;
+    /** Último acesso; sem ele a linha some. */
+    ultimoAcesso?: Date | null;
+    /** Ações da página inicial (ex.: "Novo cadastro"). */
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * Cabeçalho de sessão da página inicial: foto, data por extenso, saudação
+ * pela hora, cargo · unidade e último acesso. Substitui o `CabecalhoPagina` na home.
+ */
+export declare function BoasVindas({ nome, cargo, sigla, foto, ultimoAcesso, children, className }: BoasVindasProps): import("react").JSX.Element;

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;