@celke/kole-react 0.4.1 → 0.6.0

package/dist/components/Avaliacao/Avaliacao.d.ts

@@ -27,4 +27,4 @@ export interface AvaliacaoProps {
     className?: string;
 }
 /** Avaliação por estrelas (ou corações): editável, com meias estrelas, ou só leitura. */
-export declare function Avaliacao({ valor, aoMudar, max, passo, somenteLeitura, rotulo, icone, tamanho, mensagens, aoPassar, limpavel, textoOcupado, className, }: AvaliacaoProps): import("react").JSX.Element;
+export declare function Avaliacao({ valor, aoMudar, max, passo, somenteLeitura, rotulo, icone, tamanho, mensagens, aoPassar, limpavel, textoOcupado: textoOcupadoProp, className, }: AvaliacaoProps): import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+export interface PessoaAvatar {
+    nome: string;
+    foto?: string;
+}
+export interface GrupoAvataresProps {
+    pessoas: PessoaAvatar[];
+    /** Quantos aparecem; o resto vira "+N" (padrão: 3). */
+    max?: number;
+    /** Tamanho CSS de cada avatar (padrão: `1.75rem`). */
+    tamanho?: string;
+    /** Começo do nome acessível (padrão: "Responsáveis"), seguido dos nomes. */
+    rotulo?: string;
+    className?: string;
+}
+/** Avatares sobrepostos com "+N" no fim (responsáveis, membros, participantes). */
+export declare function GrupoAvatares({ pessoas, max, tamanho, rotulo: rotuloProp, className }: GrupoAvataresProps): import("react").JSX.Element | null;

package/dist/components/BlocoCodigo/BlocoCodigo.d.ts

@@ -0,0 +1,15 @@
+export interface BlocoCodigoProps {
+    codigo: string;
+    /** Nome no topo (ex.: `sql`, `tsx`). Vai também em `data-linguagem` e na classe `language-*`, para um realce do app. */
+    linguagem?: string;
+    /** Botão de copiar. Padrão: `true`. */
+    copiavel?: boolean;
+    /** Quebra as linhas longas em vez de rolar para o lado. */
+    quebrarLinhas?: boolean;
+    className?: string;
+}
+/**
+ * Bloco de código com a linguagem e o botão de copiar. Sem realce de sintaxe (o app pode
+ * aplicar o dele). Serve de componente `code`/`pre` para um renderizador de Markdown.
+ */
+export declare function BlocoCodigo({ codigo, linguagem, copiavel, quebrarLinhas, className }: BlocoCodigoProps): import("react").JSX.Element;

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

@@ -7,4 +7,4 @@ export interface BotaoFecharProps extends Omit<ButtonHTMLAttributes<HTMLButtonEl
     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;
+export declare function BotaoFechar({ variante, tamanho, rotulo: rotuloProp, className, type, ...resto }: BotaoFecharProps): import("react").JSX.Element;

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

@@ -26,4 +26,4 @@ export interface BuscaProps {
     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;
+export declare function Busca({ placeholder: placeholderProp, ocupado, itensMenu, aoNavegar, aoBuscar, aoMudarTermo, atalho, children, className, }: BuscaProps): import("react").JSX.Element;

package/dist/components/Calendario/Calendario.d.ts

@@ -0,0 +1,100 @@
+/** `pri`, `ok`, `warn`, `err`, `info`, `destaque` ou uma série dos gráficos (`graf-1` a `graf-6`). */
+export type CorEvento = 'pri' | 'ok' | 'warn' | 'err' | 'info' | 'destaque' | 'graf-1' | 'graf-2' | 'graf-3' | 'graf-4' | 'graf-5' | 'graf-6';
+export interface EventoCalendario {
+    id: string | number;
+    titulo: string;
+    inicio: Date;
+    /** Sem `fim`, o evento ocupa só o horário (ou o dia) de início. */
+    fim?: Date;
+    /** Evento sem horário (aparece primeiro no dia, sem hora). */
+    diaInteiro?: boolean;
+    /** Padrão: `pri`. */
+    cor?: CorEvento;
+    /** Texto miúdo na visão lista (ex.: "Entrega", "Reunião"). */
+    categoria?: string;
+    /** Mostra o ícone de repetição (o `repetirEvento` já marca). */
+    repete?: boolean;
+    /** Id do evento base de uma série (o `repetirEvento` preenche): o app sabe qual série mudar. */
+    serie?: string | number;
+    /** Com `aoAlterarEvento`, este evento não pode ser arrastado nem esticado. */
+    fixo?: boolean;
+}
+/** Evento provisório, desenhado tracejado (ex.: o do formulário de novo evento aberto). */
+export interface RascunhoCalendario {
+    inicio: Date;
+    fim?: Date;
+    /** Padrão: "(sem título)". */
+    titulo?: string;
+    cor?: CorEvento;
+    diaInteiro?: boolean;
+}
+/** Intervalo escolhido na faixa de horários (fim exclusivo). */
+export interface IntervaloHorario {
+    inicio: Date;
+    fim: Date;
+}
+/** Novo horário de um evento arrastado ou esticado. */
+export interface MudancaEvento {
+    inicio: Date;
+    fim?: Date;
+    /** `mover`: mudou de dia ou de horário, com a mesma duração; `esticar`: mudou só o fim. */
+    tipo: 'mover' | 'esticar';
+}
+export type VisaoCalendario = 'mes' | 'semana' | 'dia' | 'lista';
+export interface PeriodoCalendario {
+    inicio: Date;
+    /** Exclusivo: o primeiro dia depois do período. */
+    fim: Date;
+    visao: VisaoCalendario;
+}
+export interface CalendarioProps {
+    eventos: EventoCalendario[];
+    /** Mês mostrado no começo. Padrão: hoje. */
+    dataInicial?: Date;
+    /** Padrão: `mes`. */
+    visaoInicial?: VisaoCalendario;
+    /** Visões oferecidas na barra. Padrão: mês, semana, dia e lista. */
+    visoes?: VisaoCalendario[];
+    /** Primeiro dia da semana: `0` = domingo (padrão), `1` = segunda. */
+    inicioSemana?: 0 | 1;
+    /** Eventos por dia na visão mês antes do "+N mais". Padrão: `3`. */
+    maxPorDia?: number;
+    /** O período visível mudou: o app busca os eventos dele. Chamado também ao montar. */
+    aoMudarPeriodo?: (periodo: PeriodoCalendario) => void;
+    aoClicarDia?: (dia: Date) => void;
+    aoClicarEvento?: (evento: EventoCalendario) => void;
+    carregando?: boolean;
+    /** Visão lista sem eventos no mês. */
+    textoVazio?: string;
+    /** Nome do calendário para leitor de tela. */
+    rotulo?: string;
+    /** "Hoje" do calendário (para testes). Padrão: a data atual. */
+    hoje?: Date;
+    /** Semana e dia: primeira e última hora da faixa de horários. Padrão: 7 e 21. */
+    horaInicio?: number;
+    horaFim?: number;
+    /** Semana e dia: clique num horário vazio, arredondado para a meia hora (ex.: criar evento ali). */
+    aoClicarHorario?: (dataHora: Date) => void;
+    /** Hora da linha do "agora" (para testes). Padrão: a hora atual, atualizada a cada minuto. */
+    agora?: Date;
+    /**
+     * Liga o arrastar: o evento vai para outro dia (mês) ou horário (semana e dia, de 15 em 15
+     * minutos), e a borda de baixo do bloco estica a duração. No toque, segure o evento antes de
+     * arrastar. Pelo teclado: Alt+setas movem e Alt+Shift+↑↓ esticam. O app grava a mudança e
+     * devolve o evento novo em `eventos`; até lá o calendário mostra o evento onde estava.
+     */
+    aoAlterarEvento?: (evento: EventoCalendario, mudanca: MudancaEvento) => void;
+    /**
+     * Semana e dia: arrastar sobre horários vazios escolhe um intervalo (de 15 em 15 minutos), e um
+     * clique escolhe a meia hora. Pelo teclado, Shift+↑↓ no cursor aumentam o intervalo e Enter
+     * confirma. Com ele, clique e Enter na faixa de horários chamam este, e não o `aoClicarHorario`.
+     */
+    aoSelecionarHorario?: (intervalo: IntervaloHorario) => void;
+    /** Evento provisório, tracejado, em qualquer visão (ex.: enquanto o formulário de novo evento está aberto). */
+    rascunho?: RascunhoCalendario | null;
+    /** Dia mostrado. Mudar a prop leva o calendário até ele (ex.: o dia escolhido num `MiniCalendario`). */
+    data?: Date;
+    className?: string;
+}
+/** Calendário de eventos com visão mês, semana, dia e lista, em pt-BR. Os eventos vêm do app; o componente só mostra e avisa os cliques. */
+export declare function Calendario({ eventos, dataInicial, visaoInicial, visoes, inicioSemana, maxPorDia, aoMudarPeriodo, aoClicarDia, aoClicarEvento, carregando, textoVazio: textoVazioProp, rotulo: rotuloProp, hoje: hojeProp, horaInicio, horaFim, aoClicarHorario, agora: agoraProp, aoAlterarEvento, aoSelecionarHorario, rascunho, data, className, }: CalendarioProps): import("react").JSX.Element;

package/dist/components/Calendario/MiniCalendario.d.ts

@@ -0,0 +1,27 @@
+export interface MiniCalendarioProps {
+    /** Dia escolhido (destacado). */
+    valor?: Date | null;
+    aoEscolher?: (dia: Date) => void;
+    /** Dias com bolinha (ex.: os que têm evento). */
+    marcados?: Date[];
+    /** Faixa destacada, com `fim` exclusivo (ex.: o `PeriodoCalendario` da semana visível no `Calendario`). */
+    destaque?: {
+        inicio: Date;
+        fim: Date;
+    } | null;
+    /** Primeiro dia da semana: `0` = domingo (padrão), `1` = segunda. */
+    inicioSemana?: 0 | 1;
+    /** O mês mostrado mudou (setas ou teclado): o app pode buscar os `marcados` dele. */
+    aoMudarMes?: (mes: Date) => void;
+    /** "Hoje" do calendário (para testes). Padrão: a data atual. */
+    hoje?: Date;
+    /** Nome para leitor de tela. Padrão: "Escolher dia". */
+    rotulo?: string;
+    className?: string;
+}
+/**
+ * Calendário pequeno de um mês, para a coluna lateral de uma agenda: escolhe o dia
+ * (setas, Home/End, Page Up/Down e Enter também valem) e mostra os dias com evento.
+ * Vai sozinho para o mês do `valor` quando ele muda.
+ */
+export declare function MiniCalendario({ valor, aoEscolher, marcados, destaque, inicioSemana, aoMudarMes, hoje: hojeProp, rotulo: rotuloProp, className, }: MiniCalendarioProps): import("react").JSX.Element;

package/dist/components/Calendario/datasCalendario.d.ts

@@ -0,0 +1,27 @@
+import { type Idioma } from '../../i18n/idiomas.js';
+import type { Textos } from '../../i18n/pt-BR.js';
+export declare let NOMES_DIA: string[];
+export declare let CURTOS_DIA: string[];
+export declare let MES: Intl.DateTimeFormat;
+export declare let DIA_LONGO: Intl.DateTimeFormat;
+export declare let HORA: Intl.DateTimeFormat;
+export declare let SEMANA_TITULO: Intl.DateTimeFormat;
+export declare let DIA_TITULO: Intl.DateTimeFormat;
+export declare let TXT: Textos['calendario'];
+/** Interno: troca formatadores e textos para o idioma ativo. */
+export declare function usarIdiomaCalendario(idioma: Idioma): void;
+export declare const meiaNoite: (d: Date) => Date;
+export declare const somaDias: (d: Date, n: number) => Date;
+/** Mesmo horário, `n` dias depois (pelo calendário, não por 24 h). */
+export declare const somaDiasHora: (d: Date, n: number, minutos?: number) => Date;
+export declare const mesmoDia: (a: Date, b: Date) => boolean;
+/** Dias de calendário de `a` até `b`. */
+export declare const difDias: (b: Date, a: Date) => number;
+export declare const chave: (d: Date) => string;
+export declare const deChave: (k: string) => Date;
+export declare const primeiraMaiuscula: (s: string) => string;
+export declare const inicioDaSemana: (d: Date, inicioSemana: 0 | 1) => Date;
+/** As 6 semanas (42 dias) que mostram o mês de `ref`, começando no `inicioSemana`. */
+export declare function gradeDoMes(ref: Date, inicioSemana: 0 | 1): Date[];
+/** Dia que as teclas de uma grade de mês levam (setas, Home/End, Page Up/Down), ou `null` para outra tecla. */
+export declare function diaPelaTecla(tecla: string, dia: Date, inicioSemana: 0 | 1): Date | null;

package/dist/components/Calendario/repetirEvento.d.ts

@@ -0,0 +1,26 @@
+import type { EventoCalendario } from './Calendario.js';
+export interface RegraRepeticao {
+    frequencia: 'diaria' | 'semanal' | 'mensal' | 'anual';
+    /** A cada quantos dias, semanas, meses ou anos. Padrão: `1`. */
+    intervalo?: number;
+    /** Semanal: dias da semana (`0` = domingo … `6` = sábado). Padrão: o dia do `inicio`. */
+    diasSemana?: number[];
+    /** Último dia possível (inclusive). */
+    ate?: Date;
+    /** Número de ocorrências, contadas desde o início da série (as `excecoes` também contam). */
+    vezes?: number;
+    /** Dias que a série pula (ex.: a ocorrência foi apagada ou movida sozinha). */
+    excecoes?: Date[];
+}
+/**
+ * Ocorrências de um evento que se repete dentro do período (fim exclusivo), prontas
+ * para o `Calendario`. Cada uma ganha `id` `"<id>@aaaa-mm-dd"`, `repete: true` e
+ * `serie` com o `id` do evento base; o horário e a duração são os do evento base.
+ *
+ * Mensal no dia 31 (ou anual em 29 de fevereiro) pula os meses (anos) sem esse dia.
+ * Use com o `aoMudarPeriodo` do calendário: calcule só o período visível.
+ */
+export declare function repetirEvento(base: EventoCalendario, regra: RegraRepeticao, periodo: {
+    inicio: Date;
+    fim: Date;
+}): EventoCalendario[];

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

@@ -24,6 +24,7 @@ export interface CampoProps extends CampoBaseProps {
  * mesmo sem ter sido tocado.
  */
 export declare const RevelarCamposCtx: import("react").Context<number>;
+/** O texto padrão em pt-BR (os campos usam o do idioma ativo). */
 export declare const MSG_OBRIGATORIO = "Campo obrigat\u00F3rio";
 interface OpcoesValidacao {
     valor: string;

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

@@ -25,4 +25,4 @@ export interface CampoBuscaProps<T> extends CampoBaseProps {
  * 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;
+export declare function CampoBusca<T>({ rotulo, dica, erro, aviso, obrigatorio, variante, className, id: idExterno, buscar, paraRotulo, paraDetalhe, chave, valor, aoMudar, minimo, atraso, placeholder: placeholderProp, disabled, vazioTexto: vazioTextoProp, }: CampoBuscaProps<T>): import("react").JSX.Element;

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

@@ -22,4 +22,4 @@ export interface CampoCidadeProps extends CampoBaseProps {
  * 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;
+export declare function CampoCidade({ uf, buscarPorUf, valor, aoMudar, placeholder: placeholderProp, disabled, ...p }: CampoCidadeProps): import("react").JSX.Element;

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

@@ -1,8 +1,21 @@
 import { type ReactNode } from 'react';
+/** Arquivo anexado à mensagem, mostrado em chip acima do texto. */
+export interface AnexoMensagem {
+    id: string | number;
+    nome: string;
+    /** Em bytes. */
+    tamanho?: number;
+    /** Tipo MIME (define o ícone). */
+    tipo?: string;
+    /** Envio em andamento, de 0 a 100: a barra aparece e o Enviar espera. */
+    progresso?: number;
+    /** O envio falhou: o chip fica vermelho com este texto. */
+    erro?: string;
+}
 export interface CampoMensagemProps {
     valor: string;
     aoMudar: (valor: string) => void;
-    /** Recebe o texto sem espaços nas pontas; nunca é chamado com texto vazio. */
+    /** Recebe o texto sem espaços nas pontas; só vem vazio quando há anexos. */
     aoEnviar: (texto: string) => void;
     /** Uma resposta está chegando: o Enviar vira Parar. */
     gerando?: boolean;
@@ -17,6 +30,12 @@ export interface CampoMensagemProps {
     autoFocus?: boolean;
     /** Botões próprios do app à esquerda do Enviar (anexar, escolher documentos…). */
     acoesExtras?: ReactNode;
+    /** Chips dos arquivos anexados, acima do texto. Com anexos, dá para enviar sem texto. */
+    anexos?: AnexoMensagem[];
+    /** Mostra o "×" em cada chip. */
+    aoRemoverAnexo?: (id: AnexoMensagem['id']) => void;
+    /** Arquivos soltos sobre o campo ou colados nele (Ctrl+V de uma imagem): o app valida e envia. */
+    aoAdicionarArquivos?: (arquivos: File[]) => void;
     /** Rótulo do campo para leitores de tela. */
     rotulo?: string;
     rotuloEnviar?: string;

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

@@ -7,4 +7,4 @@ export interface CarregandoProps {
     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;
+export declare function Carregando({ mensagem: mensagemProp, logo, bloqueante, className }: CarregandoProps): import("react").JSX.Element;

package/dist/components/ChatFlutuante/ChatFlutuante.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export interface ChatFlutuanteProps {
+    /** Normalmente uma `Conversa` (com o `CampoMensagem` no `campo`). Ocupa a altura do painel. */
+    children: ReactNode;
+    /** Título do painel. Padrão: "Fale com a gente". */
+    titulo?: string;
+    /** Abaixo do título (ex.: "Respondemos em poucos minutos"). */
+    subtitulo?: ReactNode;
+    /** Foto (URL) ou nó (ícone, `Avatar`) ao lado do título. Padrão: o ícone do botão. */
+    avatar?: ReactNode;
+    /** Texto do botão. No celular, só o ícone aparece. Padrão: o `titulo`. */
+    rotuloBotao?: string;
+    icone?: IconeProp;
+    /** Bolinha com a contagem sobre o botão (mensagens não lidas). */
+    naoLidas?: number;
+    /** Controlado: o app abre e fecha. */
+    aberto?: boolean;
+    aoMudarAberto?: (aberto: boolean) => void;
+    abertoInicial?: boolean;
+    /** Canto da tela. Padrão: `direita`. */
+    lado?: 'direita' | 'esquerda';
+    /** Ações no topo do painel, antes do fechar (ex.: "Nova conversa"). */
+    acoes?: ReactNode;
+    className?: string;
+}
+/**
+ * Chat de atendimento para site: botão fixo no canto que abre um painel com a conversa.
+ * Esc fecha e o foco volta ao botão; no celular o painel ocupa a tela.
+ */
+export declare function ChatFlutuante({ children, titulo: tituloProp, subtitulo, avatar, rotuloBotao, icone, naoLidas, aberto: abertoProp, aoMudarAberto, abertoInicial, lado, acoes, className, }: ChatFlutuanteProps): import("react").JSX.Element;

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

@@ -18,4 +18,4 @@ export interface ConversaProps {
  * ú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;
+export declare function Conversa({ children, vazio, campo, larguraMaxima, rotulo: rotuloProp, rotuloIrParaFim: rotuloIrParaFimProp, className, }: ConversaProps): import("react").JSX.Element;

package/dist/components/Estrutura/Estrutura.d.ts

@@ -1,6 +1,7 @@
 import { type MouseEvent, type ReactNode } from 'react';
 import { type IconeProp } from '../../utils/Icone.js';
 import { type ModeloTrilha } from '../Trilha/Trilha.js';
+import { type Idioma } from '../../i18n/idiomas.js';
 export interface ItemNav {
     rotulo: string;
     icone?: IconeProp;
@@ -100,8 +101,18 @@ export interface EstruturaProps {
     busca?: ReactNode | false;
     placeholderBusca?: string;
     aoBuscar?: (termo: string) => void;
-    /** Controles extras à direita da topbar. */
+    /** Controles extras à direita da topbar (somem no celular). */
     complementosTopbar?: ReactNode;
+    /**
+     * Seletor do contexto do sistema (ex.: `SeletorContexto` com Pessoal ×
+     * Empresa, ou a filial), à esquerda da topbar. Fica visível também no celular.
+     */
+    contexto?: ReactNode;
+    /**
+     * Idiomas do seletor na topbar, ao lado do tema (ex.: `['pt-BR', 'en', 'es']`).
+     * Sem a prop, o seletor não aparece. A troca vai para o `ProvedorPreferencias`.
+     */
+    idiomas?: Idioma[];
     children?: ReactNode;
 }
 /**
@@ -110,4 +121,4 @@ export interface EstruturaProps {
  * Responsiva: abaixo de 64rem a sidebar vira sobreposição; abaixo de 48rem,
  * gaveta com hambúrguer.
  */
-export declare function Estrutura({ marca, nav, rotaAtual, aoNavegar, renderLink, usuario, menuUsuario, aoEscolherMenuUsuario, notificacoes, aoEscolherNotificacao, menuDesenvolvimento, aoEscolherMenuDesenvolvimento, ambiente, versao, rodapeSidebar, rodape, modeloTrilha, submenu, busca, placeholderBusca, aoBuscar, complementosTopbar, children, }: EstruturaProps): import("react").JSX.Element;
+export declare function Estrutura({ marca, nav, rotaAtual, aoNavegar, renderLink, usuario, menuUsuario, aoEscolherMenuUsuario, notificacoes, aoEscolherNotificacao, menuDesenvolvimento, aoEscolherMenuDesenvolvimento, ambiente, versao, rodapeSidebar, rodape, modeloTrilha, submenu, busca, placeholderBusca: placeholderBuscaProp, aoBuscar, complementosTopbar, contexto, idiomas, children, }: EstruturaProps): import("react").JSX.Element;

package/dist/components/Form/Form.d.ts

@@ -67,7 +67,7 @@ export interface FormProps {
  * Formulário de cadastro. Agrupe os campos em `<FormSecao>`; a grade de
  * colunas, o menu lateral e o rodapé com Salvar/Cancelar vêm prontos.
  */
-export declare function Form({ arranjo, titulo: tituloProp, entidade, modo, trilha, identidade, icone, aberto, tamanho, aoSalvar, aoCancelar, salvando, pendencias, menu, menuTitulo, menuAtivo, aoEscolherMenu, acoes, acoesPadrao, posicaoAcoes, rotuloSalvar, children, className, }: FormProps): import("react").JSX.Element | null;
+export declare function Form({ arranjo, titulo: tituloProp, entidade, modo, trilha, identidade, icone, aberto, tamanho, aoSalvar, aoCancelar, salvando, pendencias, menu, menuTitulo: menuTituloProp, menuAtivo, aoEscolherMenu, acoes, acoesPadrao, posicaoAcoes, rotuloSalvar: rotuloSalvarProp, children, className, }: FormProps): import("react").JSX.Element | null;
 export interface FormSecaoProps {
     legenda: string;
     icone?: IconeProp;

package/dist/components/Girador/Girador.d.ts

@@ -12,4 +12,4 @@ export interface GiradorProps {
     className?: string;
 }
 /** Indicador de atividade em linha (spinner). Para espera de seção inteira, use `Carregando`. */
-export declare function Girador({ tipo, cor, tamanho, rotulo, mostrarRotulo, className }: GiradorProps): import("react").JSX.Element;
+export declare function Girador({ tipo, cor, tamanho, rotulo: rotuloProp, mostrarRotulo, className }: GiradorProps): import("react").JSX.Element;

package/dist/components/Grafico/GraficoRosca.d.ts

@@ -0,0 +1,31 @@
+import type { DadoGrafico, GraficoBaseProps } from './tipos.js';
+export interface GraficoRoscaProps extends GraficoBaseProps {
+    /** Cada item é uma fatia. Valores zero, negativos ou sem dado ficam de fora. */
+    dados: DadoGrafico[];
+    /** Campo com o nome da fatia (ex.: a categoria). */
+    chaveRotulo: string;
+    chaveValor: string;
+    /** Campo com a cor de cada fatia (padrão: `--graf-1`, `--graf-2`… na ordem). */
+    chaveCor?: string;
+    /** Formata os valores (padrão: número pt-BR). Ex.: `(v) => formatarMoeda(v)`. */
+    formatar?: (valor: number) => string;
+    /** Texto do meio quando nenhuma fatia está ativa. Padrão: "Total" e a soma das visíveis. */
+    centro?: {
+        rotulo?: string;
+        valor?: string;
+    };
+    /**
+     * Junta as menores numa fatia "Outros" a partir desta quantidade (ex.: `6`
+     * mostra as 5 maiores e "Outros"). Sem ela, mostra todas.
+     */
+    maxFatias?: number;
+    rotuloOutros?: string;
+    /** Espessura do anel, em fração do raio (0,1 a 0,9). Padrão `0.32`. */
+    espessura?: number;
+    /** Legenda ao lado (`lado`, se couber) ou `abaixo`. Padrão `lado`. */
+    posicaoLegenda?: 'lado' | 'abaixo';
+    /** Clique numa fatia (ex.: filtrar os lançamentos da categoria). */
+    aoEscolher?: (item: DadoGrafico, indice: number) => void;
+}
+/** Participação de cada parte num todo (despesas por categoria, carteira, canais de venda). */
+export declare function GraficoRosca(props: GraficoRoscaProps): import("react").JSX.Element;

package/dist/components/Grafico/MolduraGrafico.d.ts

@@ -33,8 +33,43 @@ export declare function Amostra({ cor, forma, tracejada }: {
     forma: FormaLegenda;
     tracejada?: boolean;
 }): import("react").JSX.Element;
+/**
+ * Interno: os textos dos gráficos no idioma ativo. Também registra o idioma
+ * para as funções puras de `escalas.ts` (números e datas dos eixos).
+ */
+export declare function useTextosGrafico(): {
+    categoria: string;
+    data: string;
+    valor: string;
+    semDados: string;
+    verGrafico: string;
+    verDados: string;
+    series: string;
+    esconderSerie: string;
+    mostrarSerie: string;
+    eixo: string;
+    eixoEsquerdo: string;
+    eixoDireito: string;
+    semDado: string;
+    pontos: string;
+    destaque: string;
+    tendencia: string;
+    ponto: string;
+    pontoN: string;
+    linha: string;
+    outros: string;
+    item: string;
+    participacao: string;
+    total: string;
+    totalDe: string;
+    fatias: string;
+    esconderFatia: string;
+    mostrarFatia: string;
+    alta: string;
+    queda: string;
+};
 /** Esqueleto comum dos gráficos: título, legenda, ver dados, carregando e vazio. */
-export declare function MolduraGrafico({ titulo, altura, legenda, carregando, textoVazio, verDados, animacao, className, semDados, itensLegenda, aoAlternarSerie, tabela, nota, children, }: MolduraGraficoProps): import("react").JSX.Element;
+export declare function MolduraGrafico({ titulo, altura, legenda, carregando, textoVazio: textoVazioProp, verDados, animacao, className, semDados, itensLegenda, aoAlternarSerie, tabela, nota, children, }: MolduraGraficoProps): import("react").JSX.Element;
 /** Legenda: esconde/mostra uma série, mas nunca a última visível (o gráfico ficaria em branco). */
 export declare function useSeriesOcultas(): readonly [ReadonlySet<string>, (chave: string, total: number) => void];
 /** Ponto ativo da caixa de detalhes: mouse, toque e setas do teclado andam pelos itens. */

package/dist/components/Grafico/escalas.d.ts

@@ -1,4 +1,7 @@
+import { type Idioma } from '../../i18n/idiomas.js';
 import type { EixoGrafico, EixoXGrafico, ValorGrafico } from './tipos.js';
+/** Interno: o gráfico registra o idioma ativo antes de desenhar. */
+export declare function usarIdiomaGrafico(i: Idioma): void;
 /** Valor da caixa de detalhes e da tabela: `1.234,5 mm`. */
 export declare function formatarValor(valor: ValorGrafico | undefined, eixo?: EixoGrafico): string;
 /** Rótulo do eixo: compacto a partir de 10 mil (`12,4 mil`). */

package/dist/components/InicioConversa/InicioConversa.d.ts

@@ -0,0 +1,29 @@
+import type { ReactNode } from 'react';
+import { type IconeProp } from '../../utils/Icone.js';
+export interface SugestaoConversa {
+    id?: string;
+    /** Texto do cartão (e, sem `texto`, o que vai para o campo). */
+    titulo: string;
+    /** Linha miúda abaixo do título. */
+    descricao?: string;
+    icone?: IconeProp;
+    /** O que mandar ao escolher, se for diferente do título. */
+    texto?: string;
+}
+export interface InicioConversaProps {
+    /** Saudação (ex.: "Boa tarde, Ana. Como posso ajudar?"). */
+    titulo: ReactNode;
+    descricao?: ReactNode;
+    /** Ícone ou imagem acima da saudação. */
+    icone?: IconeProp;
+    sugestoes?: SugestaoConversa[];
+    /** A pessoa escolheu uma sugestão: o app envia ou coloca o texto no campo. */
+    aoEscolher?: (sugestao: SugestaoConversa) => void;
+    /** `cartoes` (padrão): grade de cartões · `pilulas`: botões em linha, para painéis estreitos (ex.: `ChatFlutuante`). */
+    aparencia?: 'cartoes' | 'pilulas';
+    /** Abaixo das sugestões (ex.: um aviso sobre o uso dos dados). */
+    children?: ReactNode;
+    className?: string;
+}
+/** Tela inicial de uma conversa: saudação e sugestões clicáveis. Vai no `vazio` da `Conversa`. */
+export declare function InicioConversa({ titulo, descricao, icone, sugestoes, aoEscolher, aparencia, children, className }: InicioConversaProps): import("react").JSX.Element;

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

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+import { type PessoaAvatar } from '../Avatar/GrupoAvatares.js';
+import type { ContagemSubtarefas, CorKanban, EtiquetaKanban, Prioridade } from './tipos.js';
+export interface CartaoKanbanProps {
+    titulo: string;
+    /** Resumo em até duas linhas. */
+    descricao?: string;
+    /** Imagem do topo: URL ou um elemento pronto. */
+    capa?: string | ReactNode;
+    etiquetas?: EtiquetaKanban[];
+    prioridade?: Prioridade;
+    /** Data de vencimento (`Date` ou `AAAA-MM-DD`). */
+    vencimento?: Date | string;
+    /** Concluído: o prazo fica verde, sem "Atrasado". */
+    concluido?: boolean;
+    subtarefas?: ContagemSubtarefas;
+    anexos?: number;
+    comentarios?: number;
+    responsaveis?: PessoaAvatar[];
+    /** Faixa colorida na borda esquerda. */
+    cor?: CorKanban;
+    /** Espaço livre abaixo do título (ex.: valor e empresa de um negócio no CRM). */
+    extra?: ReactNode;
+    /** Botão de arrastar, recebido do `Kanban`/`QuadroArrastavel`. */
+    alca?: ReactNode;
+    /** Botões no canto superior (ex.: um `MenuSuspenso` de ações). */
+    acoes?: ReactNode;
+    /** Clicar no cartão (ou Enter no título) abre o detalhe. */
+    aoAbrir?: () => void;
+    /** Referência de "hoje" para o prazo (padrão: agora). */
+    agora?: Date;
+    className?: string;
+}
+/** Cartão de kanban: capa, etiquetas, título, prioridade, prazo, subtarefas, contadores e responsáveis. */
+export declare function CartaoKanban({ titulo, descricao, capa, etiquetas, prioridade, vencimento, concluido, subtarefas, anexos, comentarios, responsaveis, cor, extra, alca, acoes, aoAbrir, agora, className, }: CartaoKanbanProps): import("react").JSX.Element;

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

@@ -0,0 +1,62 @@
+import { type ReactNode } from 'react';
+import { type ItemMenuSuspenso } from '../MenuSuspenso/MenuSuspenso.js';
+import { type ColunaArrastavel, type PosicaoQuadro, type SoltarColuna, type SoltarItem } from '../QuadroArrastavel/QuadroArrastavel.js';
+import type { CorKanban } from './tipos.js';
+export interface ColunaKanban<T> extends ColunaArrastavel<T> {
+    titulo: string;
+    /** Faixa no topo e ponto ao lado do título. */
+    cor?: CorKanban;
+    /** Máximo de cartões (WIP): a coluna cheia não aceita mais nenhum e a contagem fica laranja. */
+    limite?: number;
+}
+export interface KanbanProps<T extends {
+    id: string;
+}, C extends ColunaKanban<T> = ColunaKanban<T>> {
+    /** Colunas com os cartões; campos a mais voltam em `aoMudar`. */
+    colunas: (ColunaKanban<T> & C)[];
+    /** As colunas na ordem nova (ao soltar um cartão ou uma coluna). */
+    aoMudar: (colunas: C[]) => void;
+    /** De onde para onde o cartão foi: grave no servidor aqui. */
+    aoSoltar?: (evento: SoltarItem<T, C>) => void;
+    /** Liga o arraste das colunas pela alça do cabeçalho e avisa a ordem nova. */
+    aoSoltarColuna?: (evento: SoltarColuna<C>) => void;
+    /** Regra extra de destino (o `limite` das colunas já é respeitado). */
+    podeSoltar?: (item: T, para: PosicaoQuadro, de: PosicaoQuadro) => boolean;
+    /** Desenha o cartão (em geral um `CartaoKanban`); ponha a `alca` nele. */
+    renderCartao: (item: T, alca: ReactNode) => ReactNode;
+    /** Nome do cartão para leitor de tela. */
+    nomeItem: (item: T) => string;
+    /** Busca e filtros: os cartões com `false` somem, e o arraste dos outros continua valendo. */
+    filtro?: (item: T) => boolean;
+    /** Mostra "Adicionar cartão" no pé de cada coluna; recebe o título digitado. */
+    aoAdicionarCartao?: (colunaId: string, titulo: string) => void;
+    /** Mostra "Adicionar coluna" no fim do quadro. */
+    aoAdicionarColuna?: (titulo: string) => void;
+    /** Liga "Renomear" no menu da coluna (o título vira um campo). */
+    aoRenomearColuna?: (colunaId: string, titulo: string) => void;
+    /** Liga "Recolher" no menu e o botão de expandir na coluna recolhida. */
+    aoRecolherColuna?: (colunaId: string, recolhida: boolean) => void;
+    /** Liga "Excluir coluna" no menu. Peça confirmação no app, se quiser (`useConfirmacao`). */
+    aoExcluirColuna?: (colunaId: string) => void;
+    /** Itens a mais no menu de cada coluna. */
+    acoesColuna?: (coluna: C) => ItemMenuSuspenso[];
+    aoEscolherAcaoColuna?: (acao: string, coluna: C) => void;
+    /** Largura de cada coluna (padrão: `18rem`). */
+    larguraColuna?: string;
+    /** Altura fixa do quadro (ex.: `calc(100dvh - 14rem)`): cada coluna rola por dentro. */
+    altura?: string;
+    vazioTitulo?: string;
+    vazioDescricao?: string;
+    /** Nome acessível do quadro (padrão: "Quadro"). */
+    rotulo?: string;
+    className?: string;
+}
+/**
+ * Quadro kanban: colunas com cabeçalho (cor, contagem, limite, menu de
+ * renomear, recolher e excluir), cartões que se arrastam entre colunas,
+ * "Adicionar cartão", "Adicionar coluna" e rolagem horizontal. Montado
+ * sobre o `QuadroArrastavel`: mouse, toque e teclado.
+ */
+export declare function Kanban<T extends {
+    id: string;
+}, C extends ColunaKanban<T> = ColunaKanban<T>>({ colunas, aoMudar, aoSoltar, aoSoltarColuna, podeSoltar, renderCartao, nomeItem, filtro, aoAdicionarCartao, aoAdicionarColuna, aoRenomearColuna, aoRecolherColuna, aoExcluirColuna, acoesColuna, aoEscolherAcaoColuna, larguraColuna, altura, vazioTitulo: vazioTituloProp, vazioDescricao: vazioDescricaoProp, rotulo: rotuloProp, className, }: KanbanProps<T, C>): import("react").JSX.Element;