@celke/kole-react 0.4.1 → 0.6.0

package/dist/components/Kanban/Pecas.d.ts

@@ -0,0 +1,30 @@
+import { type CorKanban, type Prioridade } from './tipos.js';
+export interface SeloPrioridadeProps {
+    prioridade: Prioridade;
+    /** Só a bandeira colorida (o nome fica para o leitor de tela e a dica). */
+    compacto?: boolean;
+    className?: string;
+}
+/** Bandeira com o nível de prioridade: baixa, média, alta ou crítica. */
+export declare function SeloPrioridade({ prioridade, compacto, className }: SeloPrioridadeProps): import("react").JSX.Element;
+export interface SeloPrazoProps {
+    /** Data de vencimento (`Date` ou `AAAA-MM-DD`). */
+    vencimento: Date | string;
+    /** Concluído: mostra a data em verde, sem "Atrasado". */
+    concluido?: boolean;
+    /** Dias antes do vencimento em que vira "em breve" (padrão: 2). */
+    emBreve?: number;
+    /** Referência de "hoje" (padrão: agora). */
+    agora?: Date;
+    className?: string;
+}
+/** Vencimento com cor pela situação: atrasado, hoje, em breve ou no prazo. */
+export declare function SeloPrazo({ vencimento, concluido, emBreve, agora, className }: SeloPrazoProps): import("react").JSX.Element;
+export interface EtiquetaProps {
+    rotulo: string;
+    /** Cor do ponto e do fundo (padrão: `neutro`). */
+    cor?: CorKanban;
+    className?: string;
+}
+/** Etiqueta colorida de cartão e tarefa ("Design", "Urgente"…). */
+export declare function Etiqueta({ rotulo, cor, className }: EtiquetaProps): import("react").JSX.Element;

package/dist/components/Kanban/tipos.d.ts

@@ -0,0 +1,35 @@
+import type { IconeProp } from '../../utils/Icone.js';
+import type { Severidade } from '../../utils/tipos.js';
+/** Cores de coluna e etiqueta: tokens de severidade, a marca e as séries de gráfico. */
+export type CorKanban = 'pri' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'neutro' | 'graf-1' | 'graf-2' | 'graf-3' | 'graf-4' | 'graf-5' | 'graf-6';
+/** Prioridade de cartão ou tarefa. Use só os níveis de que precisa (ex.: baixa, média e alta). */
+export type Prioridade = 'baixa' | 'media' | 'alta' | 'critica';
+/** Rótulos em pt-BR (os componentes usam o dicionário do idioma ativo: `textos.kanban`). */
+export declare const PRIORIDADES: Record<Prioridade, {
+    rotulo: string;
+    severidade: Severidade;
+}>;
+export interface EtiquetaKanban {
+    rotulo: string;
+    cor?: CorKanban;
+}
+/** Situação de uma tarefa (a coluna do kanban, quando ele é agrupado por situação). */
+export type SituacaoTarefa = 'aberta' | 'andamento' | 'bloqueada' | 'concluida';
+/** Rótulos em pt-BR (os componentes usam o dicionário do idioma ativo: `textos.kanban`). */
+export declare const SITUACOES_TAREFA: Record<SituacaoTarefa, {
+    rotulo: string;
+    severidade: Severidade;
+    icone: IconeProp;
+}>;
+/** Chave do texto de cada prioridade em `textos.kanban`. */
+export declare const CHAVE_PRIORIDADE: {
+    readonly baixa: "prioridadeBaixa";
+    readonly media: "prioridadeMedia";
+    readonly alta: "prioridadeAlta";
+    readonly critica: "prioridadeCritica";
+};
+/** Subtarefas feitas e total (o cartão mostra a barra de progresso). */
+export interface ContagemSubtarefas {
+    feitas: number;
+    total: number;
+}

package/dist/components/ListaCards/ListaCards.d.ts

@@ -25,4 +25,4 @@ export interface ListaCardsProps<T> {
     className?: string;
 }
 /** Listagem em grade de cards, irmã da `Tabela` (a ordenação fica na barra de filtros). */
-export declare function ListaCards<T>({ itens, card, chave, larguraMin, alturaCard, rotulo, carregando, atualizando, erro, aoRecarregar, vazioTitulo, vazioDescricao, vazioIcone, vazioAcoes, paginacao, className, }: ListaCardsProps<T>): import("react").JSX.Element;
+export declare function ListaCards<T>({ itens, card, chave, larguraMin, alturaCard, rotulo, carregando, atualizando, erro, aoRecarregar, vazioTitulo: vazioTituloProp, vazioDescricao, vazioIcone, vazioAcoes, paginacao, className, }: ListaCardsProps<T>): import("react").JSX.Element;

package/dist/components/ListaConversas/ListaConversas.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+export interface ItemConversa {
+    id: string | number;
+    titulo: string;
+    /** Última atividade: define o grupo (Hoje, Ontem, Últimos 7 dias…). */
+    data: Date;
+    /** Fica no grupo "Fixadas", no topo. */
+    fixada?: boolean;
+}
+export interface ListaConversasProps {
+    itens: ItemConversa[];
+    /** Id da conversa aberta. */
+    ativa?: ItemConversa['id'] | null;
+    aoEscolher: (id: ItemConversa['id']) => void;
+    /** Mostra o botão "Nova conversa". */
+    aoNova?: () => void;
+    /** Liga o "Renomear" no menu do item (edição no próprio item: Enter salva, Esc cancela). */
+    aoRenomear?: (id: ItemConversa['id'], titulo: string) => void;
+    /** Liga o "Excluir" no menu do item. A confirmação, se houver, é do app. */
+    aoExcluir?: (id: ItemConversa['id']) => void;
+    /** Liga o "Fixar"/"Desafixar" no menu do item. */
+    aoFixar?: (id: ItemConversa['id'], fixada: boolean) => void;
+    /** Campo de busca pelo título (sem acento e sem diferença de maiúsculas). Padrão: `true`. */
+    busca?: boolean;
+    carregando?: boolean;
+    /** Sem conversas. */
+    textoVazio?: string;
+    /** Acima da lista, abaixo da busca (ex.: filtros). */
+    extra?: ReactNode;
+    rotulo?: string;
+    rotuloNova?: string;
+    /** "Hoje" dos grupos (para testes). Padrão: a data atual. */
+    hoje?: Date;
+    className?: string;
+}
+/**
+ * Histórico de conversas de um assistente: "Nova conversa", busca e os itens agrupados por
+ * data, com renomear, fixar e excluir. O app guarda o histórico; a lista mostra e avisa.
+ */
+export declare function ListaConversas({ itens, ativa, aoEscolher, aoNova, aoRenomear, aoExcluir, aoFixar, busca, carregando, textoVazio: textoVazioProp, extra, rotulo: rotuloProp, rotuloNova: rotuloNovaProp, hoje: hojeProp, className, }: ListaConversasProps): import("react").JSX.Element;

package/dist/components/ListaTarefas/ListaTarefas.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import { type PessoaAvatar } from '../Avatar/GrupoAvatares.js';
+import { type ContagemSubtarefas, type EtiquetaKanban, type Prioridade, type SituacaoTarefa } from '../Kanban/tipos.js';
+export interface TarefaLista {
+    id: string;
+    titulo: string;
+    /** Marcada como feita (sem isto, vale `situacao === 'concluida'`). */
+    concluida?: boolean;
+    /** Mostrada como selo quando é "Em andamento" ou "Bloqueada". */
+    situacao?: SituacaoTarefa;
+    prioridade?: Prioridade;
+    /** Data de vencimento (`Date` ou `AAAA-MM-DD`). */
+    vencimento?: Date | string;
+    etiquetas?: EtiquetaKanban[];
+    responsaveis?: PessoaAvatar[];
+    subtarefas?: ContagemSubtarefas;
+}
+/** O que `aoReordenar` recebe além da lista nova. */
+export interface ReordenarTarefa<T> {
+    tarefa: T;
+    de: number;
+    para: number;
+}
+export interface ListaTarefasProps<T extends TarefaLista> {
+    tarefas: T[];
+    /** Marcar ou desmarcar como concluída. Sem isto, o círculo não aparece. */
+    aoConcluir?: (tarefa: T, concluida: boolean) => void;
+    /** Clicar na tarefa abre o detalhe (ex.: um `Dialogo` lateral). */
+    aoAbrir?: (tarefa: T) => void;
+    /** Liga o arraste para reordenar; recebe a lista na ordem nova, ao soltar. */
+    aoReordenar?: (tarefas: T[], evento: ReordenarTarefa<T>) => void;
+    /** Id da tarefa aberta no detalhe (fica destacada). */
+    selecionada?: string;
+    /** Visão e filtros: as tarefas com `false` somem, e a ordem das outras continua valendo ao arrastar. */
+    filtro?: (tarefa: T) => boolean;
+    /** Conteúdo a mais em cada linha, antes dos responsáveis. */
+    extra?: (tarefa: T) => ReactNode;
+    carregando?: boolean;
+    vazioTitulo?: string;
+    vazioDescricao?: string;
+    vazioAcoes?: ReactNode;
+    /** Referência de "hoje" para os prazos (padrão: agora). */
+    agora?: Date;
+    /** Nome acessível da lista (padrão: "Tarefas"). */
+    rotulo?: string;
+    className?: string;
+}
+/**
+ * Lista de tarefas: marcar como feita, prioridade, prazo, etiquetas e
+ * responsáveis em cada linha; reordena arrastando (mouse, toque e teclado).
+ */
+export declare function ListaTarefas<T extends TarefaLista>({ tarefas, aoConcluir, aoAbrir, aoReordenar, selecionada, filtro, extra, carregando, vazioTitulo: vazioTituloProp, vazioDescricao, vazioAcoes, agora, rotulo: rotuloProp, className, }: ListaTarefasProps<T>): import("react").JSX.Element;

package/dist/components/Mensagem/Mensagem.d.ts

@@ -37,4 +37,4 @@ export interface MensagemProps {
     className?: string;
 }
 /** Uma mensagem da `Conversa`: bolha com autor, hora, estado e ações. */
-export declare function Mensagem({ autor, children, nome, avatar, hora, estado, erro, aoTentarNovamente, copiavel, textoCopia, acoes, rodape, rotuloTentarNovamente, rotuloCopiar, rotuloGerando, rotuloEnviando, className, }: MensagemProps): import("react").JSX.Element;
+export declare function Mensagem({ autor, children, nome, avatar, hora, estado, erro, aoTentarNovamente, copiavel, textoCopia, acoes, rodape, rotuloTentarNovamente: rotuloTentarNovamenteProp, rotuloCopiar: rotuloCopiarProp, rotuloGerando: rotuloGerandoProp, rotuloEnviando: rotuloEnviandoProp, className, }: MensagemProps): import("react").JSX.Element;

package/dist/components/NavegadorPeriodo/NavegadorPeriodo.d.ts

@@ -0,0 +1,28 @@
+import { type Periodo } from '../../utils/periodo.js';
+import { type BotaoProps } from '../Botao/Botao.js';
+export interface AtalhoPeriodo {
+    rotulo: string;
+    /** O período, ou uma função de "agora" (ex.: o mês passado). */
+    periodo: Periodo | ((agora: Date) => Periodo);
+}
+export interface NavegadorPeriodoProps {
+    valor: Periodo;
+    aoMudar: (periodo: Periodo) => void;
+    /** Atalhos do painel. Padrão: este mês, mês passado, este trimestre, este ano e ano passado. */
+    atalhos?: AtalhoPeriodo[];
+    /** Intervalo livre (de/até) no painel. Padrão `true`. */
+    personalizado?: boolean;
+    /** "Hoje" de referência (testes, fuso do servidor). */
+    agora?: Date;
+    /** Nome do grupo para leitor de tela. Padrão "Período". */
+    rotulo?: string;
+    tamanho?: BotaoProps['tamanho'];
+    className?: string;
+}
+/** Atalhos padrão com os rótulos em pt-BR (sem `atalhos`, o componente usa os do idioma ativo). */
+export declare const ATALHOS_PERIODO: AtalhoPeriodo[];
+/**
+ * "‹ novembro de 2026 ›": anda de mês em mês (ou trimestre, ano, intervalo)
+ * pelas setas, e o rótulo abre os atalhos e o intervalo livre.
+ */
+export declare function NavegadorPeriodo({ valor, aoMudar, atalhos: atalhosProp, personalizado, agora, rotulo: rotuloProp, tamanho, className }: NavegadorPeriodoProps): import("react").JSX.Element;

package/dist/components/Picklist/Picklist.d.ts

@@ -25,4 +25,4 @@ export interface PicklistProps<T> extends Omit<CampoBaseProps, 'variante'> {
  * setas movem o foco, Espaço marca, Enter transfere, Alt+setas reordena;
  * duplo clique também transfere.
  */
-export declare function Picklist<T>({ rotulo, dica, erro, aviso, obrigatorio, className, id: idExterno, valor: valorBruto, aoMudar, rotuloFonte, rotuloAlvo, paraRotulo, renderItem, filtro, dragdrop, reordenar, alturaLista, disabled, }: PicklistProps<T>): import("react").JSX.Element;
+export declare function Picklist<T>({ rotulo, dica, erro, aviso, obrigatorio, className, id: idExterno, valor: valorBruto, aoMudar, rotuloFonte: rotuloFonteProp, rotuloAlvo: rotuloAlvoProp, paraRotulo, renderItem, filtro, dragdrop, reordenar, alturaLista, disabled, }: PicklistProps<T>): import("react").JSX.Element;

package/dist/components/Preferencias/Preferencias.d.ts

@@ -1,4 +1,6 @@
 import { type ReactNode } from 'react';
+import { type TextosParciais } from '../../i18n/textos.js';
+import type { Idioma } from '../../i18n/idiomas.js';
 /** `sistema` = segue o modo do sistema operacional, inclusive quando ele muda com a página aberta. */
 export type Tema = 'claro' | 'escuro' | 'sistema';
 export type Densidade = 'compacta' | 'confortavel' | 'espacosa';
@@ -7,9 +9,13 @@ export interface Preferencias {
     /** O tema que está na tela: com `sistema`, o do sistema operacional agora. */
     escuro: boolean;
     densidade: Densidade;
+    /** Idioma dos textos da biblioteca (padrão `pt-BR`). */
+    idioma: Idioma;
     definirTema: (t: Tema) => void;
     alternarTema: () => void;
     definirDensidade: (d: Densidade) => void;
+    /** Troca o idioma: todos os componentes mudam na hora, e a escolha fica lembrada. */
+    definirIdioma: (i: Idioma) => void;
 }
 /**
  * Script para o `<head>` que aplica tema e densidade ANTES da primeira pintura.
@@ -20,22 +26,39 @@ export interface Preferencias {
  * SSR: `<script dangerouslySetInnerHTML={{ __html: scriptTemaInicial() }} />`.
  * Vite/HTML estático: o README traz o script pronto para colar no index.html.
  */
-export declare function scriptTemaInicial({ temaInicial, densidadeInicial }?: {
+export declare function scriptTemaInicial({ temaInicial, densidadeInicial, idiomaInicial, }?: {
     temaInicial?: Tema;
     densidadeInicial?: Densidade;
+    idiomaInicial?: Idioma;
 }): string;
 export interface ProvedorPreferenciasProps {
     children: ReactNode;
     /** Tema enquanto a pessoa não escolhe outro. Padrão: `sistema`. */
     temaInicial?: Tema;
     densidadeInicial?: Densidade;
+    /**
+     * Idioma enquanto a pessoa não escolhe outro (ex.: o `users.locale` do
+     * servidor). Padrão: `pt-BR`. O navegador não é consultado.
+     */
+    idiomaInicial?: Idioma;
+    /**
+     * Chamado ao montar e a cada troca de idioma: o lugar de sincronizar o i18n
+     * do sistema (ex.: `i18n.changeLanguage`) e de gravar a escolha no servidor.
+     */
+    aoMudarIdioma?: (idioma: Idioma) => void;
+    /**
+     * Textos por idioma, por cima dos da biblioteca: troca um texto
+     * (`{ 'pt-BR': { tabela: { rotulo: 'Lista' } } }`) ou acrescenta um idioma
+     * (`{ fr: { … } }`; o que faltar sai em pt-BR).
+     */
+    textos?: Partial<Record<Idioma, TextosParciais>>;
 }
 /**
  * Tema (claro/escuro/sistema) e densidade, lembrados no navegador. Aplica
  * `data-theme` (`light`/`dark`/`system`) no <html> e a classe de densidade no
  * <body>. Para não piscar ao abrir, use também o `scriptTemaInicial` no <head>.
  */
-export declare function ProvedorPreferencias({ children, temaInicial, densidadeInicial }: ProvedorPreferenciasProps): import("react").JSX.Element;
+export declare function ProvedorPreferencias({ children, temaInicial, densidadeInicial, idiomaInicial, aoMudarIdioma, textos }: ProvedorPreferenciasProps): import("react").JSX.Element;
 export declare function usePreferencias(): Preferencias;
 /** Tudo que a biblioteca precisa na raiz do app: preferências, toasts e confirmação. */
 export declare function ProvedorUi({ children, ...prefs }: ProvedorPreferenciasProps): import("react").JSX.Element;

package/dist/components/QuadroArrastavel/QuadroArrastavel.d.ts

@@ -4,24 +4,77 @@ export interface ColunaArrastavel<T> {
     /** Nome da coluna (anunciado ao mover pelo teclado). */
     titulo?: string;
     itens: T[];
+    /** Recolhida: os itens somem e soltar nela põe o item no fim. */
+    recolhida?: boolean;
+}
+/** Lugar de um item: id da coluna e posição nela (contando sem o próprio item). */
+export interface PosicaoQuadro {
+    coluna: string;
+    indice: number;
+}
+/** O que `aoSoltar` recebe quando um item muda de lugar. */
+export interface SoltarItem<T, C = ColunaArrastavel<T>> {
+    item: T;
+    de: PosicaoQuadro;
+    para: PosicaoQuadro;
+    /** As colunas já com o item no lugar novo (as mesmas de `aoMudar`). */
+    colunas: C[];
+}
+/** O que `aoSoltarColuna` recebe quando uma coluna muda de lugar. */
+export interface SoltarColuna<C> {
+    coluna: C;
+    de: number;
+    para: number;
+    colunas: C[];
 }
 export interface QuadroArrastavelProps<T extends {
     id: string;
-}> {
-    colunas: ColunaArrastavel<T>[];
-    /** Recebe as colunas já reordenadas. */
-    aoMudar: (colunas: ColunaArrastavel<T>[]) => void;
+}, C extends ColunaArrastavel<T> = ColunaArrastavel<T>> {
+    /** Colunas com os itens; podem ter campos a mais (cor, limite…), que voltam em `aoMudar`. */
+    colunas: (ColunaArrastavel<T> & C)[];
+    /** Recebe as colunas na ordem nova, uma vez, ao soltar (durante o arraste o quadro mostra uma prévia). */
+    aoMudar: (colunas: C[]) => void;
+    /** Avisa de onde para onde o item foi, ao soltar: é o que o servidor precisa para gravar. */
+    aoSoltar?: (evento: SoltarItem<T, C>) => void;
+    /**
+     * Regra de destino: `false` impede soltar o item ali (ex.: coluna cheia).
+     * `de` é o lugar onde o arraste começou.
+     */
+    podeSoltar?: (item: T, para: PosicaoQuadro, de: PosicaoQuadro) => boolean;
+    /** Filtro: os itens com `false` ficam escondidos, mas continuam no lugar ao arrastar os outros. */
+    visivel?: (item: T) => boolean;
     /** Desenha o item; ponha a `alca` (botão de arrastar) onde quiser, ex.: no cabeçalho do card. */
     renderItem: (item: T, alca: ReactNode) => ReactNode;
     /** Nome de cada item para leitor de tela (ex.: o título do card). */
     nomeItem: (item: T) => string;
+    /**
+     * `grade` (padrão) = as colunas dividem a largura e quebram linha ·
+     * `faixa` = colunas de largura fixa lado a lado, com rolagem horizontal (kanban).
+     */
+    layout?: 'grade' | 'faixa';
+    /** Na `faixa`, a largura de cada coluna; na `grade`, a largura mínima (padrão: 18rem e 16rem). */
+    larguraColuna?: string;
+    /** Topo de cada coluna. `alca` é o botão de arrastar a coluna (com `colunasArrastaveis`). */
+    cabecalhoColuna?: (coluna: C, alca: ReactNode) => ReactNode;
+    /** Pé de cada coluna (ex.: "Adicionar cartão"). Some na coluna recolhida. */
+    rodapeColuna?: (coluna: C) => ReactNode;
+    /** As colunas também se reordenam, pela alça do cabeçalho. */
+    colunasArrastaveis?: boolean;
+    /** Avisa a coluna que mudou de lugar, ao soltar. */
+    aoSoltarColuna?: (evento: SoltarColuna<C>) => void;
+    /** Conteúdo depois da última coluna, na mesma fileira (ex.: "Adicionar coluna"). */
+    fim?: ReactNode;
+    /** Classe extra de cada coluna (vale também para a cópia que segue o ponteiro). */
+    classeColuna?: (coluna: C) => string | undefined;
+    /** Nome acessível do quadro. */
+    rotulo?: string;
     className?: string;
 }
 /**
  * Colunas de itens (cards) que se reordenam arrastando, entre colunas
  * inclusive. Mouse, toque e teclado: na alça, Espaço pega/solta, setas movem,
- * Esc devolve ao lugar de origem.
+ * Esc devolve ao lugar de origem. Perto da borda, a tela rola sozinha.
  */
 export declare function QuadroArrastavel<T extends {
     id: string;
-}>({ colunas, aoMudar, renderItem, nomeItem, className }: QuadroArrastavelProps<T>): import("react").JSX.Element;
+}, C extends ColunaArrastavel<T> = ColunaArrastavel<T>>({ colunas, aoMudar, aoSoltar, podeSoltar, visivel, renderItem, nomeItem, layout, larguraColuna, cabecalhoColuna, rodapeColuna, colunasArrastaveis, aoSoltarColuna, fim, classeColuna, rotulo, className, }: QuadroArrastavelProps<T, C>): import("react").JSX.Element;

package/dist/components/Referencias/Referencias.d.ts

@@ -21,4 +21,4 @@ export interface ReferenciasProps {
     className?: string;
 }
 /** Lista recolhível de fontes/citações de uma mensagem (vai no `rodape` da `Mensagem`). */
-export declare function Referencias({ itens, abertoInicial, rotulo, rotuloMostrarMais, rotuloMostrarMenos, className, }: ReferenciasProps): import("react").JSX.Element | null;
+export declare function Referencias({ itens, abertoInicial, rotulo: rotuloProp, rotuloMostrarMais: rotuloMostrarMaisProp, rotuloMostrarMenos: rotuloMostrarMenosProp, className, }: ReferenciasProps): import("react").JSX.Element | null;

package/dist/components/SeletorContexto/SeletorContexto.d.ts

@@ -0,0 +1,32 @@
+import { type IconeProp } from '../../utils/Icone.js';
+import { type ItemMenuSuspenso } from '../MenuSuspenso/MenuSuspenso.js';
+export interface OpcaoContexto {
+    id: string;
+    nome: string;
+    /** Linha miúda (ex.: "Pessoal", o CNPJ, a cidade da filial). */
+    descricao?: string;
+    /** Ícone no quadrado; sem ele, as iniciais do nome. */
+    icone?: IconeProp;
+    /** Cor do quadrado: `pri`, `ok`, `warn`, `err`, `info`, `graf-1` a `graf-6` ou qualquer cor CSS. */
+    cor?: string;
+}
+export interface SeletorContextoProps {
+    opcoes: OpcaoContexto[];
+    /** `id` da opção atual. */
+    valor: string;
+    aoMudar: (id: string) => void;
+    /** Título do menu e nome acessível. Padrão "Trocar de espaço". */
+    rotulo?: string;
+    /** Itens depois das opções (ex.: "Gerenciar espaços"), separados por um divisor. */
+    acoes?: ItemMenuSuspenso[];
+    aoEscolherAcao?: (id: string) => void;
+    /** Só o quadrado, sem o nome (topo estreito). Padrão: some sozinho abaixo de 40rem. */
+    compacto?: boolean;
+    className?: string;
+}
+/**
+ * Troca o contexto do sistema inteiro: Pessoal × Empresa, a empresa do grupo,
+ * a filial, a escola. Fica no topo (prop `contexto` da `Estrutura`) ou onde o
+ * app quiser.
+ */
+export declare function SeletorContexto({ opcoes, valor, aoMudar, rotulo: rotuloProp, acoes, aoEscolherAcao, compacto, className }: SeletorContextoProps): import("react").JSX.Element | null;

package/dist/components/SeletorIdioma/Bandeira.d.ts

@@ -0,0 +1,10 @@
+import type { Idioma } from '../../i18n/idiomas.js';
+/**
+ * Bandeira do idioma em SVG próprio (emoji de bandeira não aparece no Windows).
+ * Desenho simplificado, para 1em; decorativa (o nome do idioma vai em texto).
+ * Idioma sem bandeira própria mostra o globo.
+ */
+export declare function Bandeira({ idioma, className }: {
+    idioma: Idioma;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/components/SeletorIdioma/SeletorIdioma.d.ts

@@ -0,0 +1,23 @@
+import { type Idioma } from '../../i18n/idiomas.js';
+import { type AlinhamentoMenu } from '../MenuSuspenso/MenuSuspenso.js';
+export interface SeletorIdiomaProps {
+    /** Idiomas oferecidos, na ordem do menu. Padrão: pt-BR, inglês e espanhol. */
+    idiomas?: readonly Idioma[];
+    /** Idioma atual. Padrão: o do `ProvedorPreferencias`. */
+    valor?: Idioma;
+    /** Padrão: troca o idioma do `ProvedorPreferencias` (que avisa o sistema em `aoMudarIdioma`). */
+    aoMudar?: (idioma: Idioma) => void;
+    /**
+     * `icone` = só a bandeira, num botão redondo (topo da `Estrutura`) ·
+     * `botao` = bandeira e nome do idioma (tela de login, preferências).
+     */
+    aparencia?: 'icone' | 'botao';
+    alinhamento?: AlinhamentoMenu;
+    className?: string;
+}
+/**
+ * Troca o idioma dos textos da biblioteca. Cada idioma aparece com o nome no
+ * próprio idioma ("Português", "English", "Español") e a bandeira; o atual
+ * fica marcado.
+ */
+export declare function SeletorIdioma({ idiomas, valor, aoMudar, aparencia, alinhamento, className }: SeletorIdiomaProps): import("react").JSX.Element;

package/dist/components/Site/CabecalhoSecao.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+export interface CabecalhoSecaoProps {
+    titulo: string;
+    /** Texto curto acima do título, em maiúsculas e laranja (ex.: "Novidades"). */
+    sobretitulo?: string;
+    descricao?: ReactNode;
+    /** À direita (ex.: um link "Ver todos →"). */
+    acao?: ReactNode;
+    /** Nível do título. Padrão: `2`. */
+    nivel?: 1 | 2 | 3;
+    /** `titulo` de página (maior) ou de `secao` (padrão). */
+    tamanho?: 'pagina' | 'secao';
+    /** `centro` para seções centralizadas (FAQ, planos). */
+    alinhamento?: 'inicio' | 'centro';
+    className?: string;
+}
+/** Título de seção ou de página do site, com sobretítulo e ação. */
+export declare function CabecalhoSecao({ titulo, sobretitulo, descricao, acao, nivel, tamanho, alinhamento, className }: CabecalhoSecaoProps): import("react").JSX.Element;

package/dist/components/Site/CampoPesquisa.d.ts

@@ -0,0 +1,15 @@
+export interface CampoPesquisaProps {
+    valor: string;
+    aoMudar: (valor: string) => void;
+    /** Enter ou o botão. Recebe o termo sem espaços nas pontas. */
+    aoPesquisar?: (termo: string) => void;
+    placeholder?: string;
+    /** Nome do campo para leitor de tela. Padrão: o `placeholder`. */
+    rotulo?: string;
+    rotuloBotao?: string;
+    /** `padrao` = pílula clara · `destaque` = pílula branca grande com botão laranja, para a faixa marinha. */
+    aparencia?: 'padrao' | 'destaque';
+    className?: string;
+}
+/** Busca em pílula com botão (`role="search"`), como nas faixas e listagens do site. */
+export declare function CampoPesquisa({ valor, aoMudar, aoPesquisar, placeholder: placeholderProp, rotulo, rotuloBotao: rotuloBotaoProp, aparencia, className }: CampoPesquisaProps): import("react").JSX.Element;

package/dist/components/Site/CardConteudo.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react';
+export interface CardConteudoProps {
+    titulo: string;
+    /**
+     * `vertical` = mídia 16:9 no topo (grade de posts) · `destaque` = mídia no topo e título grande ·
+     * `horizontal` = mídia à esquerda (post em destaque) · `compacto` = miniatura quadrada à esquerda ·
+     * `linha` = item de listagem, com um quadro à direita (`lateral`).
+     */
+    formato?: 'vertical' | 'destaque' | 'horizontal' | 'compacto' | 'linha';
+    resumo?: ReactNode;
+    /** Linha acima do título: `Badge`s, categoria, data. */
+    etiquetas?: ReactNode;
+    /** Imagem (ou qualquer nó) do cartão. */
+    midia?: ReactNode;
+    /** Linha miúda no fim (ex.: "Autor · 05/11/2026 · 6 min de leitura"). */
+    rodape?: ReactNode;
+    /** `linha`: quadro à direita (ex.: preço, quantidade). */
+    lateral?: ReactNode;
+    /** O cartão inteiro vira um link (o do título, esticado: o leitor de tela lê só o título). */
+    href?: string;
+    /** Sem `href`: o cartão inteiro vira um botão. */
+    aoClicar?: () => void;
+    /** Nível do título. Padrão: `3`. */
+    nivel?: 2 | 3 | 4;
+    className?: string;
+}
+/** Cartão de post, notícia, produto ou pessoa do site, em cinco formatos. */
+export declare function CardConteudo({ titulo, formato, resumo, etiquetas, midia, rodape, lateral, href, aoClicar, nivel, className }: CardConteudoProps): import("react").JSX.Element;

package/dist/components/Site/CardDepoimento.d.ts

@@ -0,0 +1,14 @@
+export interface CardDepoimentoProps {
+    /** O depoimento, sem aspas (o cartão põe). */
+    texto: string;
+    nome: string;
+    /** Linha abaixo do nome (ex.: "Cargo · Empresa"). */
+    cargo?: string;
+    /** URL da foto. Sem ela, as iniciais do `nome`. */
+    foto?: string;
+    /** De 0 a 5 estrelas. Padrão: `5`; `0` esconde. */
+    nota?: number;
+    className?: string;
+}
+/** Depoimento de cliente: estrelas, citação e quem disse. */
+export declare function CardDepoimento({ texto, nome, cargo, foto, nota, className }: CardDepoimentoProps): import("react").JSX.Element;

package/dist/components/Site/CardPlano.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+export interface CardPlanoProps {
+    nome: string;
+    descricao?: string;
+    /** Preço já formatado, sem a moeda (ex.: "99"). */
+    preco: string;
+    /** Padrão: "R$". */
+    moeda?: string;
+    /** Depois do preço (ex.: "/mês"). */
+    periodo?: string;
+    /** O que o plano inclui. */
+    itens: string[];
+    /** Plano recomendado: cartão marinho e selo no alto. */
+    destaque?: boolean;
+    /** Texto do selo do `destaque`. Padrão: "Mais escolhido". */
+    rotuloDestaque?: string;
+    /** Botão no pé do cartão (ex.: `<Botao bloco …>`). */
+    acao?: ReactNode;
+    className?: string;
+}
+/** Cartão de plano ou preço: nome, valor, lista do que inclui e o botão de contratar. */
+export declare function CardPlano({ nome, descricao, preco, moeda, periodo, itens, destaque, rotuloDestaque: rotuloDestaqueProp, acao, className }: CardPlanoProps): import("react").JSX.Element;

package/dist/components/Site/CardRecurso.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export interface CardRecursoProps {
+    titulo: ReactNode;
+    /** Texto de apoio. */
+    children?: ReactNode;
+    /** Ícone num quadrado azul-claro. */
+    icone?: IconeProp;
+    /** No lugar do ícone, um número em laranja (ex.: "01" nos valores da empresa). */
+    numero?: string;
+    /** Texto miúdo acima do título (ex.: "Telefone" no cartão de contato). */
+    sobretitulo?: string;
+    /** Abaixo do texto (ex.: um link "Saiba mais →"). */
+    acao?: ReactNode;
+    /** `vertical` = ícone em cima · `horizontal` = ícone à esquerda. */
+    formato?: 'vertical' | 'horizontal';
+    /** Nível do título. Padrão: `3`. */
+    nivel?: 2 | 3 | 4;
+    className?: string;
+}
+/** Cartão de diferencial, serviço, valor ou canal de contato: ícone (ou número), título e texto. */
+export declare function CardRecurso({ titulo, children, icone, numero, sobretitulo, acao, formato, nivel, className }: CardRecursoProps): import("react").JSX.Element;

package/dist/components/Site/ConteudoArtigo.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export interface ConteudoArtigoProps {
+    /** HTML comum do texto: `p`, `h2`, `h3`, `ul`, `ol`, `blockquote`, `a`, `img`, `figure`. */
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Área de leitura de posts e páginas de texto (termos, privacidade): largura de
+ * cerca de 70 caracteres e o estilo dos elementos comuns. Markdown convertido em
+ * HTML pelo app deve chegar já sanitizado.
+ */
+export declare function ConteudoArtigo({ children, className }: ConteudoArtigoProps): import("react").JSX.Element;

package/dist/components/Site/DestaqueSite.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+export interface DestaqueSiteProps {
+    /** Título principal (vira o `<h1>` da página). */
+    titulo: string;
+    /** Trecho do título pintado em laranja (ex.: "melhor preço"). */
+    realce?: string;
+    /** Acima de tudo (ex.: uma `Trilha` nas páginas internas). */
+    topo?: ReactNode;
+    /** Selo acima do título (ex.: "Atualizado hoje"). */
+    selo?: ReactNode;
+    /** Texto curto acima do título, em maiúsculas (alternativa ao selo). */
+    sobretitulo?: string;
+    descricao?: ReactNode;
+    /** Abaixo do texto: normalmente um `CampoPesquisa aparencia="destaque"` ou botões. */
+    children?: ReactNode;
+    /** `escuro` (padrão) = faixa marinha com coluna à direita · `claro` = fundo claro, texto centralizado e `midia` embaixo. */
+    aparencia?: 'escuro' | 'claro';
+    /** Coluna da direita, no `escuro` (ex.: imagem do produto). */
+    lateral?: ReactNode;
+    /** Imagem larga abaixo do texto, no `claro` (cantos de cima arredondados, encostada na borda de baixo). */
+    midia?: ReactNode;
+    /** Nível do título. Padrão: `1`. */
+    nivel?: 1 | 2;
+    className?: string;
+}
+/** Faixa marinha de abertura (hero): selo, título com realce, texto, busca e uma coluna livre. */
+export declare function DestaqueSite({ topo, titulo, realce, selo, sobretitulo, descricao, children, aparencia, lateral, midia, nivel, className }: DestaqueSiteProps): import("react").JSX.Element;