@adatechnology/conversations-ui 0.1.0-rc.9 → 0.1.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as react from 'react';
-import react__default, { ReactNode, CSSProperties, FormEvent } from 'react';
-import { y as MessagePayload, A as ResolveMediaUrl, v as InteractiveSelection, t as InteractivePayload, p as ConversationsFeatures, m as ConversationSummary, h as ConversationChannel, L as ListConversationsParams, o as ConversationsApi, S as SSEProvider, w as ListDocumentsParams, i as ConversationDocument, n as ConversationTemplate } from './types-B5C1DLu1.js';
-export { C as CHANNEL_CAPABILITIES, a as CHANNEL_FILTER_ALL, b as CONVERSATION_CHANNEL, c as ChannelCapabilities, d as ChannelFilter, e as ChannelFilterOption, f as CompanyDocument, g as CompanyDocumentPage, j as ConversationDocumentPage, k as ConversationEventSource, l as ConversationPage, q as ConversationsTheme, r as ConversationsUIConfig, D as DEFAULT_CONVERSATION_CHANNEL, F as FormatContactHandleParams, H as HANDLE_KIND, s as HandleKind, I as InteractiveOption, u as InteractiveSection, M as MediaRenderer, x as MediaRendererProps, R as REOPEN_MECHANISM, z as ReopenMechanism, B as capabilitiesOf, E as channelFiltersFor, G as contactFlag, J as formatContactHandle } from './types-B5C1DLu1.js';
+import react__default, { ReactNode, CSSProperties, UIEvent, FormEvent, RefObject } from 'react';
+import { U as MessagePayload, a3 as ResolveMediaUrl, P as InteractiveSelection, V as MessageTranscription, N as InteractivePayload, x as ConversationsFeatures, u as ConversationSummary, j as ConversationChannel, Q as ListConversationsParams, w as ConversationsApi, a5 as SSEProvider, aa as TranscriptionMode, R as ListDocumentsParams, k as ConversationDocument, v as ConversationTemplate, f as ChannelFilter, g as ChannelFilterOption, q as ConversationSimulatorClient, s as ConversationSimulatorPanelLabels, Z as PreviewUploadedMedia } from './ConversationSimulatorPanel--5fIzXWY.js';
+export { A as AudioRecorderButton, a as AudioRecorderButtonLabels, b as AudioRecorderButtonProps, C as CHANNEL_CAPABILITIES, c as CHANNEL_FILTER_ALL, d as CONVERSATION_CHANNEL, e as ChannelCapabilities, h as CompanyDocument, i as CompanyDocumentPage, l as ConversationDocumentPage, m as ConversationEventSource, n as ConversationPage, y as ConversationsTheme, z as ConversationsUIConfig, E as DEFAULT_AUDIO_RECORDER_BUTTON_LABELS, F as DEFAULT_CONVERSATION_CHANNEL, H as DEFAULT_MAX_RECORDING_MILLISECONDS, J as FormatContactHandleParams, K as HANDLE_KIND, L as HandleKind, M as InteractiveOption, O as InteractiveSection, S as MediaRenderer, T as MediaRendererProps, a1 as REOPEN_MECHANISM, a2 as ReopenMechanism, a7 as SendSimulatorMediaParams, a8 as SimulatorMediaKind, ab as TranscriptionStatus, ae as capabilitiesOf, af as channelFiltersFor, ag as contactFlag, ak as formatContactHandle } from './ConversationSimulatorPanel--5fIzXWY.js';
+import '@adatechnology/meta-whatsapp-contracts/testing';
 
 interface MessageBubbleProps {
     message: MessagePayload;
@@ -21,9 +22,15 @@ interface MessageBubbleProps {
      * no histórico da inbox: o operador vê o que foi oferecido, sem responder no lugar do cliente.
      */
     onInteractiveSelect?: (selection: InteractiveSelection) => void;
+    /**
+     * Pede a transcrição do áudio. Ausente, o balão usa `transcribeAudio` do `ConversationsApi` do
+     * contexto — passe apenas para sobrescrever. Sem nenhum dos dois, o bloco de transcrição só exibe
+     * o que já veio pronto do backend.
+     */
+    onTranscribeAudio?: (messageId: string) => Promise<MessageTranscription | void>;
     className?: string;
 }
-declare function MessageBubble({ message, isMine, senderName, isFirstInGroup, isSelecting, isSelected, onToggleSelect, onResolveMediaUrl, onInteractiveSelect, className, }: MessageBubbleProps): react.JSX.Element;
+declare function MessageBubble({ message, isMine, senderName, isFirstInGroup, isSelecting, isSelected, onToggleSelect, onResolveMediaUrl, onInteractiveSelect, onTranscribeAudio, className, }: MessageBubbleProps): react.JSX.Element;
 
 interface InteractiveMessageLabels {
     /** Fallback do rótulo do botão que abre a lista, quando o payload não traz um. */
@@ -43,8 +50,18 @@ interface ConversationWallpaperProps {
     className?: string;
     /** Ajusta ou substitui o fundo padrão — para produto com identidade visual própria. */
     style?: CSSProperties;
+    /**
+     * Rolagem da área de mensagens. Par do `ref`: é este elemento que rola, então é aqui que
+     * `useScrollToLatestMessage` observa a posição para saber se o operador está acompanhando o fim.
+     */
+    onScroll?: (event: UIEvent<HTMLDivElement>) => void;
 }
-declare function ConversationWallpaper({ children, className, style }: ConversationWallpaperProps): react.JSX.Element;
+/**
+ * `forwardRef` porque quem controla a rolagem é de fora — o hook precisa do elemento para saltar
+ * até a última mensagem. `forwardRef` e não `ref` como prop: o pacote suporta React 18, onde
+ * ref-como-prop ainda não existe.
+ */
+declare const ConversationWallpaper: react.ForwardRefExoticComponent<ConversationWallpaperProps & react.RefAttributes<HTMLDivElement>>;
 
 interface ConversationLocales {
     bubble: {
@@ -68,6 +85,20 @@ interface ConversationLocales {
         untitledDocument: string;
         downloadFile: string;
     };
+    transcription: {
+        label: string;
+        copy: string;
+        copied: string;
+        transcribe: string;
+        transcribing: string;
+        retry: string;
+        failed: string;
+        /** Áudio processado sem fala detectada — distinto de "não transcrito". */
+        empty: string;
+        unsupported: string;
+        showMore: string;
+        showLess: string;
+    };
     selection: {
         select: string;
     };
@@ -92,6 +123,33 @@ interface AudioPlayerProps {
 }
 declare function AudioPlayer({ src, isMine }: AudioPlayerProps): react.JSX.Element;
 
+interface AudioTranscriptionProps {
+    transcription?: MessageTranscription | null;
+    /**
+     * Pede a transcrição ao backend. Ausente, o bloco nunca oferece o botão — um host em modo
+     * automático não tem rota para isso, e desenhar um botão que estoura no clique é pior do que não
+     * desenhar nada.
+     *
+     * O que for devolvido é exibido na hora. Sem isso o texto só apareceria no próximo refetch da
+     * lista, e transcrição não emite evento de tempo real: o operador clicaria, veria o spinner
+     * terminar e continuaria sem o texto na tela.
+     */
+    onTranscribe?: () => Promise<MessageTranscription | void>;
+    isMine?: boolean;
+}
+/**
+ * Transcrição sob a nota de voz, com botão de copiar.
+ *
+ * Copiar é o motivo de o bloco existir: o operador cola o pedido do cliente no sistema interno, no
+ * orçamento, na busca. Seleção manual de texto dentro de um balão de chat é exatamente onde o
+ * arrasto do mouse falha — pega o balão vizinho, o horário, o nome do remetente.
+ *
+ * `navigator.clipboard.writeText` com try/catch silencioso, mesmo padrão de `MessageText.tsx`: a API
+ * exige contexto seguro e permissão, e um host servindo em HTTP simples não a tem. Falhar sem alarme
+ * é o certo — o texto continua na tela para seleção manual.
+ */
+declare function AudioTranscription({ transcription, onTranscribe, isMine }: AudioTranscriptionProps): react.JSX.Element | null;
+
 interface EmojiPickerLabels {
     search: string;
     noResults: string;
@@ -128,10 +186,30 @@ declare const EMOJI_CATEGORIES: readonly EmojiCategory[];
  */
 declare function searchEmojis(query: string): readonly EmojiEntry[];
 
+/**
+ * Mensagem pronta que o atendente cola no campo com um clique.
+ *
+ * `text` aceita string com `{{variavel}}` ou função: a string cobre o caso comum (copy fixa com o
+ * nome do cliente no meio) sem o host escrever código, e a função cobre o que precisa de lógica —
+ * escolher texto por produto, pluralizar, formatar moeda.
+ */
+interface QuickReply {
+    key: string;
+    /** O que aparece no chip, emoji incluso: `👋 Saudação`. */
+    label: string;
+    text: string | ((variables: Readonly<Record<string, string>>) => string);
+}
+/**
+ * Troca `{{nome}}` pelos valores passados. Variável ausente vira string vazia, e não o literal
+ * `{{nome}}`: mandar "Olá {{nome}}!" para o cliente é pior que mandar "Olá !".
+ */
+declare function applyQuickReplyVariables(template: string, variables?: Readonly<Record<string, string>>): string;
+declare function resolveQuickReply(quickReply: QuickReply, variables?: Readonly<Record<string, string>>): string;
 interface MessageComposerLabels {
     emoji: string;
     attach: string;
     send: string;
+    removeAttachment: string;
 }
 declare const DEFAULT_MESSAGE_COMPOSER_LABELS: MessageComposerLabels;
 interface MessageComposerProps {
@@ -145,11 +223,22 @@ interface MessageComposerProps {
     maxLength?: number;
     disabled?: boolean;
     acceptedFileTypes?: string;
+    /**
+     * Ocupa o lugar do botão de enviar enquanto não há nada para enviar — é onde o WhatsApp põe o
+     * microfone. Fora do campo, o botão vira um bloco solto ao lado do pill e quebra a barra.
+     */
+    idleAction?: ReactNode;
+    /** Mensagens prontas exibidas acima do campo. Vazio ou ausente, a faixa não é renderizada. */
+    quickReplies?: readonly QuickReply[];
+    /** Valores para `{{variavel}}` — tipicamente nome do cliente, produto, protocolo. */
+    quickReplyVariables?: Readonly<Record<string, string>>;
     className?: string;
     classNames?: Partial<MessageComposerClassNames>;
 }
 interface MessageComposerClassNames {
     root: string;
+    quickReplies: string;
+    quickReply: string;
     field: string;
 }
 /**
@@ -159,7 +248,91 @@ interface MessageComposerClassNames {
  * Produto com regra própria passa `acceptedFileTypes`.
  */
 declare const DEFAULT_ACCEPTED_FILE_TYPES: string;
-declare const MessageComposer: ({ onSend, onAttach, value: externalValue, onChange: externalOnChange, features, placeholder, maxLength, disabled, acceptedFileTypes, className, classNames, labels, }: MessageComposerProps) => react.JSX.Element;
+declare const MessageComposer: ({ onSend, onAttach, value: externalValue, onChange: externalOnChange, quickReplies, quickReplyVariables, features, placeholder, maxLength, disabled, acceptedFileTypes, idleAction, className, classNames, labels, }: MessageComposerProps) => react.JSX.Element;
+
+/** Cada ação que a barra sabe oferecer. `toolbar` decide quais delas aparecem. */
+declare const RICH_COMPOSER_ACTION: {
+    readonly BOLD: "bold";
+    readonly ITALIC: "italic";
+    readonly STRIKETHROUGH: "strikethrough";
+    readonly MONOSPACE: "monospace";
+    readonly EMOJI: "emoji";
+    readonly ATTACH: "attach";
+    readonly VARIABLES: "variables";
+};
+type RichComposerAction = (typeof RICH_COMPOSER_ACTION)[keyof typeof RICH_COMPOSER_ACTION];
+/** Texto das dicas. O host troca só o que quiser; o resto fica no padrão. */
+interface RichComposerTooltips {
+    bold: string;
+    italic: string;
+    strikethrough: string;
+    monospace: string;
+    emoji: string;
+    attach: string;
+    send: string;
+    variables: string;
+    /** Botão que abre a formatação recolhida, quando a barra está estreita demais para os quatro. */
+    formatting: string;
+}
+declare const DEFAULT_RICH_COMPOSER_TOOLTIPS: RichComposerTooltips;
+/**
+ * Um valor que o operador pode inserir no texto sem digitar. `value` é o que entra no campo — pode
+ * ser o dado já resolvido ("Anderson") ou um marcador a resolver depois ("{{nome}}"): quem decide é
+ * o host, porque só ele sabe se a substituição acontece aqui ou no envio.
+ */
+interface RichComposerVariable {
+    id: string;
+    label: string;
+    value: string;
+    /** Prévia do que será inserido, para o operador conferir antes de tocar. */
+    tooltip?: string;
+}
+/** Uma resposta rápida: o que o operador lê no chip e o que cai no campo ao tocar nele. */
+interface RichComposerQuickReply {
+    id: string;
+    label: string;
+    text: string;
+    /** Dica ao passar o mouse. Sem isto, o chip não tem `title` — rótulo curto já se explica. */
+    tooltip?: string;
+}
+/** Handle imperativo: `contentEditable` controlado pelo React perde o cursor a cada tecla. */
+interface RichMessageComposerHandle {
+    setContent: (text: string) => void;
+    clear: () => void;
+    focus: () => void;
+}
+interface RichMessageComposerProps {
+    /** Texto na notação do WhatsApp (`*negrito*`), não HTML. */
+    value: string;
+    onChange: (value: string) => void;
+    onSend: () => void;
+    onAttachFiles?: (files: FileList) => void;
+    quickReplies?: RichComposerQuickReply[];
+    /** Variáveis que o operador pode inserir no texto. Vazio ou ausente, o botão não aparece. */
+    variables?: RichComposerVariable[];
+    /**
+     * Quais ações aparecem. Ausente, todas aparecem — menos as que não têm como funcionar (anexo sem
+     * `onAttachFiles` some sozinho, porque botão que não faz nada é pior que botão nenhum).
+     */
+    toolbar?: Partial<Record<RichComposerAction, boolean>>;
+    tooltips?: Partial<RichComposerTooltips>;
+    placeholder?: string;
+    disabled?: boolean;
+    isSending?: boolean;
+    /** Ocupa o lugar do enviar enquanto não há nada para enviar — onde o WhatsApp põe o microfone. */
+    idleAction?: ReactNode;
+    /** Prévia dos anexos já escolhidos, desenhada pelo host acima da barra. */
+    attachmentsPreview?: ReactNode;
+    /**
+     * Há anexo na fila esperando envio. O campo não conhece a fila — é do host — e sem essa dica ele
+     * concluía que não havia nada a enviar: com uma imagem anexada e nenhum texto, o botão de enviar
+     * dava lugar ao `idleAction` e a imagem ficava presa.
+     */
+    hasQueuedAttachments?: boolean;
+    acceptedFileTypes?: string;
+    className?: string;
+}
+declare const RichMessageComposer: react.ForwardRefExoticComponent<RichMessageComposerProps & react.RefAttributes<RichMessageComposerHandle>>;
 
 interface WhatsAppMessageEditorLabels {
     bold: string;
@@ -257,6 +430,22 @@ declare function ToastProvider({ children }: {
 }): react.JSX.Element;
 declare function useToast(): ToastContextValue;
 
+/**
+ * Camada única de dicas do pacote.
+ *
+ * O `title` nativo existia em todos os botões e mesmo assim a dica "não aparecia": o navegador
+ * espera de 1 a 2 segundos antes de desenhar, o balão sai fora do tema e some ao menor movimento do
+ * mouse. Aqui a dica é do produto — aparece em 120ms, com o mesmo contraste do resto da interface.
+ *
+ * Um só ouvinte no documento atende a interface inteira: cada botão declara `data-cv-tooltip` e não
+ * precisa de estado, ref ou wrapper próprio. O balão é impresso em `document.body` via portal
+ * porque `overflow` de container (a régua de respostas rápidas rola na horizontal) recortaria um
+ * balão desenhado dentro do próprio botão.
+ */
+/** Atributo que marca um elemento como portador de dica. */
+declare const TOOLTIP_ATTRIBUTE = "data-cv-tooltip";
+declare function TooltipLayer(): react.ReactPortal | null;
+
 interface StatusTicksProps {
     status: string;
     title?: string;
@@ -322,23 +511,23 @@ type ConversationWindow = (typeof CONVERSATION_WINDOW)[keyof typeof CONVERSATION
 declare const WINDOW_FILTERS: readonly [{
     readonly value: "all";
     readonly label: "Todas";
-    readonly dotClass: "";
+    readonly tone: "";
 }, {
     readonly value: "fresh";
     readonly label: "<12h";
-    readonly dotClass: "bg-green-500";
+    readonly tone: "fresh";
 }, {
     readonly value: "warning";
     readonly label: "12-21h";
-    readonly dotClass: "bg-yellow-500";
+    readonly tone: "warning";
 }, {
     readonly value: "critical";
     readonly label: "21-24h";
-    readonly dotClass: "bg-red-500";
+    readonly tone: "critical";
 }, {
     readonly value: "expired";
     readonly label: ">24h";
-    readonly dotClass: "bg-gray-400";
+    readonly tone: "expired";
 }];
 type WindowOfParams = {
     readonly lastInboundAt: string | null;
@@ -356,6 +545,45 @@ type WindowOfParams = {
 declare function windowOf(params: WindowOfParams): ConversationWindow;
 declare function formatStalledFor(lastAt: string, now: number): string;
 
+/**
+ * Copyright (c) 2026 Ada Technology. MIT License.
+ *
+ * Há quanto tempo o cliente espera resposta.
+ *
+ * Não confundir com `conversationWindow`: aquilo é a janela de sessão da plataforma (o que o canal
+ * ainda deixa enviar), isto é serviço (quanto o cliente esperou). Os dois divergem justamente no
+ * caso que interessa — respondida a conversa, o relógio do SLA para e o da janela continua correndo.
+ *
+ * A conta sai de dados que a listagem já traz: se a última mensagem foi do cliente, ninguém
+ * respondeu ainda e a espera conta desde ela. Se a última foi nossa, não há espera pendente.
+ */
+declare const REPLY_LATENCY: {
+    /** Até 6h — dentro do combinado. */
+    readonly WITHIN: "within";
+    /** 6h a 12h — passou do combinado. */
+    readonly LATE: "late";
+    /** Acima de 12h. */
+    readonly CRITICAL: "critical";
+};
+type ReplyLatency = (typeof REPLY_LATENCY)[keyof typeof REPLY_LATENCY];
+declare const REPLY_LATENCY_LATE_HOURS = 6;
+declare const REPLY_LATENCY_CRITICAL_HOURS = 12;
+type ReplyLatencyParams = {
+    /** Direção da última mensagem. Ausente = desconhecida, e aí não se afirma espera. */
+    readonly lastDirection?: 'inbound' | 'outbound' | undefined;
+    readonly lastInboundAt: string | null;
+    readonly now: number;
+};
+/**
+ * `null` quando não há espera a mostrar — conversa já respondida, ou cliente que nunca escreveu.
+ *
+ * Devolver uma faixa nesses casos encheria a lista de selos em conversa que não deve nada, e o
+ * alerta que aponta para todo lado não aponta para lugar nenhum.
+ */
+declare function replyLatencyOf(params: ReplyLatencyParams): ReplyLatency | null;
+/** Só o que passou do combinado merece alerta — é o corte que a lista usa para destacar. */
+declare function isReplyOverdue(latency: ReplyLatency | null): boolean;
+
 type ConversationRowClassNames = {
     root: string;
     windowBar: string;
@@ -414,8 +642,8 @@ interface ConversationHeaderClassNames {
  */
 interface ConversationHeaderUtility {
     key: string;
-    /** Emoji, para casar com os utilitários nativos do cabeçalho. */
-    icon: string;
+    /** Ícone da biblioteca (lucide), no tamanho dos utilitários nativos: `<Play size={16} />`. */
+    icon: ReactNode;
     label: string;
     run: () => void;
     active?: boolean;
@@ -440,20 +668,35 @@ declare function ConversationHeader({ conversation, busy, onTakeover, onReturnTo
 
 /**
  * "Suas Seleções": o que o bot já coletou na conversa. Para o atendente que assume no meio, é a
- * diferença entre ler o transcript inteiro e ver o estado em duas linhas.
+ * diferença entre ler o transcript inteiro e ver o estado de relance.
  *
  * O pacote não interpreta o contexto — ele é `Record<string, unknown>` e cada produto nomeia as
  * próprias chaves. O host traduz para `entries`; aqui só se decide como mostrar.
+ *
+ * Desenho em paridade com financiamento-imobiliario-bot/apps/web/src/components/SelectionsSummary.tsx:
+ * card com gradiente, badge de contagem, pills de status no cabeçalho e grid de cards com borda
+ * colorida por estado. O que ficou diferente de lá, e por quê, está comentado no ponto.
  */
+/**
+ * `completed` tem valor, `pending` ainda não foi coletado, `editing` é o cliente refazendo a
+ * resposta. O host só precisa mandar `status` para o terceiro caso — os dois primeiros saem do
+ * próprio `value`, e exigir o campo quebraria quem já usa o painel.
+ */
+type ConversationContextStatus = 'completed' | 'pending' | 'editing';
 interface ConversationContextEntry {
     key: string;
     label: string;
     value?: string | undefined;
     icon?: string;
+    status?: ConversationContextStatus;
 }
 interface ConversationContextPanelLabels {
     title: string;
     empty: string;
+    collapse: string;
+    expand: string;
+    /** Placeholder do card ainda não coletado. */
+    notCollected: string;
 }
 declare const DEFAULT_CONVERSATION_CONTEXT_LABELS: ConversationContextPanelLabels;
 interface ConversationContextPanelClassNames {
@@ -464,11 +707,23 @@ interface ConversationContextPanelClassNames {
 }
 interface ConversationContextPanelProps {
     entries: readonly ConversationContextEntry[];
+    /**
+     * Estado inicial. Ausente, abre sozinho no desktop quando há algum dado preenchido.
+     *
+     * Existe porque "abre sozinho" nem sempre é o que o produto quer: com 1 de 6 campos preenchidos o
+     * painel ocupa altura mostrando quase só pendências, e empurra a conversa — que é o que se veio ver.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Rótulo do fluxo em curso, exibido em azul ao lado do título — no financiamento é o produto
+     * escolhido ("Consórcio", "MCMV"). Ausente, o cabeçalho fica só com título e contagens.
+     */
+    flowLabel?: string;
     labels?: Partial<ConversationContextPanelLabels>;
     className?: string;
     classNames?: Partial<ConversationContextPanelClassNames>;
 }
-declare function ConversationContextPanel({ entries, labels: labelsOverride, className, classNames, }: ConversationContextPanelProps): react.JSX.Element;
+declare function ConversationContextPanel({ entries, defaultOpen, flowLabel, labels: labelsOverride, className, classNames, }: ConversationContextPanelProps): react.JSX.Element;
 
 interface WindowExpiredNoticeLabels {
     title: string;
@@ -512,6 +767,8 @@ interface DocumentsLibraryLabels {
     sortMostRecent: string;
     sortOldest: string;
     clearFilters: string;
+    upload: string;
+    uploadError: string;
     total: (count: number) => string;
     page: (current: number, last: number) => string;
 }
@@ -543,6 +800,160 @@ interface DocumentsLibraryProps {
 }
 declare function DocumentsLibrary({ perPage, onOpenConversation, labels: labelsOverride, className, classNames, }: DocumentsLibraryProps): react.JSX.Element | null;
 
+type SortDirection = 'asc' | 'desc';
+interface SortableHeadProps {
+    readonly label: string;
+    readonly field: string;
+    readonly activeField: string;
+    readonly direction: SortDirection;
+    readonly onSort: (field: string) => void;
+    readonly className?: string;
+}
+declare function SortableHead({ label, field, activeField, direction, onSort, className }: SortableHeadProps): react.JSX.Element;
+interface FilterOption {
+    readonly value: string;
+    readonly label: string;
+}
+interface MultiSelectFilterProps {
+    readonly label: string;
+    readonly options: readonly FilterOption[];
+    readonly selected: readonly string[];
+    readonly onChange: (selected: readonly string[]) => void;
+    readonly className?: string;
+}
+declare function MultiSelectFilter({ label, options, selected, onChange, className }: MultiSelectFilterProps): react.JSX.Element;
+interface BulkActionBarProps {
+    readonly selectedCount: number;
+    readonly selectedLabel: (count: number) => string;
+    readonly clearLabel: string;
+    readonly onClear: () => void;
+    readonly children?: ReactNode;
+}
+declare function BulkActionBar({ selectedCount, selectedLabel, clearLabel, onClear, children }: BulkActionBarProps): react.JSX.Element | null;
+interface ListingPaginationProps {
+    readonly page: number;
+    readonly total: number;
+    readonly perPage: number;
+    readonly perPageOptions?: readonly number[];
+    readonly onPageChange: (page: number) => void;
+    readonly onPerPageChange?: (perPage: number) => void;
+    readonly labels: {
+        readonly show: string;
+        readonly perPage: string;
+        readonly total: (count: number) => string;
+        readonly page: (current: number, last: number) => string;
+        readonly previous: string;
+        readonly next: string;
+    };
+}
+declare function ListingPagination({ page, total, perPage, perPageOptions, onPageChange, onPerPageChange, labels, }: ListingPaginationProps): react.JSX.Element;
+
+/**
+ * Vocabulário da biblioteca de arquivos. Sobrescrevível campo a campo: o produto troca "cliente"
+ * por "lead" ou o idioma inteiro sem manter uma cópia da tela para isso.
+ */
+interface DocumentsWorkspaceLabels {
+    readonly title: string;
+    readonly subtitle: (total: number) => string;
+    readonly searchPlaceholder: string;
+    readonly empty: string;
+    readonly noResults: string;
+    readonly loading: string;
+    readonly failure: string;
+    readonly view: string;
+    readonly download: string;
+    readonly remove: string;
+    readonly removeConfirm: (filename: string) => string;
+    readonly openConversation: string;
+    readonly sourceFilter: string;
+    readonly categoryFilter: string;
+    readonly startDate: string;
+    readonly endDate: string;
+    readonly clearFilters: string;
+    readonly selectAllPage: string;
+    readonly selectRow: string;
+    readonly bulkSelected: (count: number) => string;
+    readonly bulkClear: string;
+    readonly bulkDownloadZip: string;
+    readonly bulkRemove: (count: number) => string;
+    readonly bulkRemoveConfirm: (count: number) => string;
+    readonly upload: string;
+    readonly uploadError: string;
+    readonly columnFilename: string;
+    readonly columnContact: string;
+    readonly columnType: string;
+    readonly columnSize: string;
+    readonly columnSource: string;
+    readonly columnDate: string;
+    readonly columnActions: string;
+    readonly sourceLabels: Readonly<Record<string, string>>;
+    readonly categoryLabels: Readonly<Record<string, string>>;
+    readonly show: string;
+    readonly perPage: string;
+    readonly total: (count: number) => string;
+    readonly page: (current: number, last: number) => string;
+    readonly previousPage: string;
+    readonly nextPage: string;
+}
+declare const DEFAULT_DOCUMENTS_WORKSPACE_LABELS: DocumentsWorkspaceLabels;
+
+interface DocumentsWorkspaceClassNames {
+    root: string;
+    header: string;
+    filters: string;
+    table: string;
+    row: string;
+    status: string;
+}
+interface DocumentsWorkspaceProps {
+    readonly perPage?: number;
+    readonly perPageOptions?: readonly number[];
+    /** Abrir a conversa de origem. Ausente, o número aparece como texto e não como link. */
+    readonly onOpenConversation?: (conversationId: string) => void;
+    /** Origens filtráveis. Ausente, usa o vocabulário padrão (`customer`, `agent`, `bot`). */
+    readonly sources?: readonly FilterOption[];
+    /** Categorias de arquivo. Lista vazia esconde o filtro — nem todo host classifica anexo. */
+    readonly categories?: readonly FilterOption[];
+    /** Recorte por data. Desligado quando o backend não sabe filtrar por período. */
+    readonly dateFilter?: boolean;
+    /**
+     * Filtros do produto (cliente, unidade, campanha). Recebe os parâmetros extras atuais e devolve
+     * os controles; o que o produto guardar aqui viaja em `extra` para o `getAllDocuments`.
+     */
+    readonly renderFilters?: (context: DocumentsFiltersContext) => ReactNode;
+    readonly labels?: Partial<DocumentsWorkspaceLabels>;
+    readonly className?: string;
+    readonly classNames?: Partial<DocumentsWorkspaceClassNames>;
+    /** Espelhar filtros e paginação na URL. Desligado em preview, onde não há rota de verdade. */
+    readonly syncUrl?: boolean;
+}
+interface DocumentsFiltersContext {
+    readonly extra: Readonly<Record<string, string | number>>;
+    readonly setExtra: (next: Readonly<Record<string, string | number>>) => void;
+}
+declare function DocumentsWorkspace({ perPage: initialPerPage, perPageOptions, onOpenConversation, sources, categories, dateFilter, renderFilters, labels: labelsOverride, className, classNames, syncUrl, }: DocumentsWorkspaceProps): react.JSX.Element | null;
+
+/**
+ * Estado de listagem espelhado na URL — ordenação, filtros e paginação (regra `web.md` §7).
+ *
+ * Escrito sobre `history.replaceState` e não sobre um router: o pacote roda em três produtos com
+ * routers diferentes, e exigir um deles arrastaria dependência de framework para dentro do módulo.
+ * `replaceState` também é o comportamento certo aqui — filtrar não é navegar, e cada tecla digitada
+ * na busca não deve virar uma entrada no botão "voltar".
+ */
+/** `enabled: false` mantém o mesmo contrato de estado sem tocar na URL — para uso em preview e teste. */
+interface UrlStateOptions {
+    readonly enabled?: boolean;
+}
+declare function useUrlStringState(key: string, initial: string, { enabled }?: UrlStateOptions): [string, (next: string) => void];
+declare function useUrlNumberState(key: string, initial: number, { enabled }?: UrlStateOptions): [number, (next: number) => void];
+declare function useUrlArrayState(key: string, { enabled }?: UrlStateOptions): [readonly string[], (next: readonly string[]) => void];
+/**
+ * Espera o usuário parar de digitar antes de deixar o valor chegar à query. Sem isto, cada tecla
+ * na busca vira uma chamada de rede e uma reescrita de URL.
+ */
+declare function useDebouncedValue<TValue>(value: TValue, delayMs?: number): TValue;
+
 /**
  * Arquivos trocados na conversa. Sai do transcript e vira lista própria porque anexo é o que o
  * atendente mais precisa reencontrar depois — rolar meses de mensagens para achar um comprovante é
@@ -661,6 +1072,49 @@ declare function useDarkMode(): {
     toggle: () => void;
 };
 
+interface DarkModeToggleLabels {
+    /** Ação de ir para o tema escuro — é o rótulo lido enquanto o tema claro está ativo. */
+    toDark: string;
+    toLight: string;
+}
+interface DarkModeToggleClassNames {
+    /** O tamanho do ícone vem daqui quando o host usa a própria escala (`size-4`, `size-5`). */
+    icon?: string;
+    label?: string;
+}
+interface DarkModeToggleProps {
+    isDark: boolean;
+    onToggle: () => void;
+    /** Rótulo ao lado do ícone. Só-ícone exige a área de toque mínima, que a classe `cv-touch` dá. */
+    showLabel?: boolean;
+    labels?: Partial<DarkModeToggleLabels>;
+    /**
+     * Substitui a aparência do botão. As classes passam por `tailwind-merge`, então utilitário do
+     * host vence o do pacote em vez de somar: `px-4` descarta o `px-3` daqui.
+     *
+     * A exceção é utilitário de token do host (`rounded-panel`), que o merge não reconhece como
+     * família e deixa passar junto com o `rounded-lg` do pacote — aí quem decide é a ordem no CSS
+     * gerado, não a do atributo. Nesse caso use a forma arbitrária (`rounded-[var(--radius-panel)]`),
+     * que o merge entende e substitui.
+     */
+    className?: string;
+    classNames?: DarkModeToggleClassNames;
+}
+declare const DEFAULT_DARK_MODE_TOGGLE_LABELS: DarkModeToggleLabels;
+/**
+ * Interruptor de tema, apresentacional: o estado vem do host, junto com `useDarkMode`.
+ *
+ * Ele não monta o hook de propósito. `useDarkMode` é o controlador — escreve a classe `dark` no
+ * `<html>` e persiste a escolha —, e uma barra lateral que também existe como gaveta fica montada
+ * duas vezes na mesma tela. Dois controladores guardam estados iniciais separados, e o segundo
+ * botão passa a mostrar o ícone contrário ao tema que está no ar. Com o estado no host, o hook é
+ * chamado uma vez acima dos dois e as duas cópias concordam.
+ *
+ * O rótulo nomeia o destino, não o estado atual: no claro se lê "Tema escuro", que é o que o clique
+ * faz. `aria-pressed` diria o oposto na mesma frase, então fica de fora.
+ */
+declare function DarkModeToggle({ isDark, onToggle, showLabel, labels, className, classNames, }: DarkModeToggleProps): react.JSX.Element;
+
 /**
  * Detecta tela estreita para decisões que CSS não resolve — como abrir ou não um painel por padrão.
  *
@@ -847,6 +1301,47 @@ interface WelcomeFarewellFormProps {
 }
 declare function WelcomeFarewellForm({ welcomeMessage, onWelcomeMessageChange, farewellMessage, onFarewellMessageChange, onSave, saving, saveSuccess, welcomePlaceholders, farewellPlaceholders, labels: labelsOverride, }: WelcomeFarewellFormProps): react.JSX.Element;
 
+interface TranscriptionSettingsFormLabels {
+    sectionTitle: string;
+    enabled: string;
+    enabledHint: string;
+    modeTitle: string;
+    modeAuto: string;
+    modeAutoHint: string;
+    modeOnDemand: string;
+    modeOnDemandHint: string;
+    unavailable: string;
+    save: string;
+    saving: string;
+    saveSuccess: string;
+}
+interface TranscriptionSettingsFormProps {
+    enabled: boolean;
+    onEnabledChange: (value: boolean) => void;
+    mode: TranscriptionMode;
+    onModeChange: (value: TranscriptionMode) => void;
+    onSave: (event: FormEvent) => void;
+    /**
+     * A capacidade existe no servidor (engine e credencial configurados)?
+     *
+     * Distinto de `enabled`: isto é "o ambiente consegue", aquilo é "esta empresa quer". Sem a
+     * distinção, um lojista ligaria o interruptor num ambiente sem engine e concluiria que o produto
+     * está quebrado — o texto nunca apareceria e nada explicaria por quê.
+     */
+    isAvailable?: boolean;
+    saving?: boolean;
+    saveSuccess?: boolean;
+    labels?: Partial<TranscriptionSettingsFormLabels>;
+}
+/**
+ * Interruptor de transcrição por empresa, para a tela de configurações.
+ *
+ * Puramente apresentacional, como os outros forms daqui: quem persiste é o host. O pacote não sabe a
+ * rota, e a política vive nas configurações do módulo (`settings.transcriptionEnabled`), não em
+ * variável de ambiente — mudar de ideia sobre transcrever não deveria exigir deploy.
+ */
+declare function TranscriptionSettingsForm({ enabled, onEnabledChange, mode, onModeChange, onSave, isAvailable, saving, saveSuccess, labels: labelsOverride, }: TranscriptionSettingsFormProps): react.JSX.Element;
+
 declare const TEMPLATE_SETTINGS_TAB: {
     readonly SELECT: "select";
     readonly CREATE: "create";
@@ -877,10 +1372,21 @@ interface WhatsAppTemplatesSettingsProps {
         onSubmit: (event: FormEvent) => void;
         submitting?: boolean;
         result?: WhatsAppCreateTemplateResult | null;
+        labels?: Partial<WhatsAppCreateTemplateFormLabels>;
+        /** Nome exibido na prévia do template criado; sem isto o form usa seu próprio fallback. */
+        previewCompanyName?: string;
+        variableExamples?: readonly string[];
     };
     labels?: Partial<WhatsAppTemplatesSettingsLabels>;
+    /** Vocabulário do formulário de seleção — separado de `labels`, que nomeia só as abas daqui. */
+    settingsLabels?: Partial<WhatsAppTemplateSettingsFormLabels>;
+    /**
+     * Formulários extras de seleção (um por papel adicional de template, ex.: despedida), empilhados
+     * abaixo do principal na mesma sub-aba. Ausente = só o papel principal, comportamento de sempre.
+     */
+    extraRoleForms?: ReactNode;
 }
-declare function WhatsAppTemplatesSettings({ labels: labelsOverride, create, ...settingsProps }: WhatsAppTemplatesSettingsProps): react.JSX.Element;
+declare function WhatsAppTemplatesSettings({ labels: labelsOverride, settingsLabels, create, extraRoleForms, ...settingsProps }: WhatsAppTemplatesSettingsProps): react.JSX.Element;
 
 interface TopicItem {
     key: string;
@@ -906,6 +1412,88 @@ interface TopicsFormProps {
 }
 declare function TopicsForm({ topics, onToggle, onMessageChange, onSave, saving, saveSuccess, labels: labelsOverride, }: TopicsFormProps): react.JSX.Element;
 
+interface BotMessages {
+    welcomeMessage: string;
+    farewellMessage: string;
+}
+interface TemplateSettings {
+    templateName: string;
+    templateLanguage: string;
+    variables: string[];
+}
+/**
+ * Papel adicional de template (ex.: despedida) além do principal (`getTemplateSettings`/
+ * `saveTemplateSettings`). Cada papel ganha seu próprio formulário empilhado na mesma aba, com
+ * carregamento e salvamento independentes — é o que permite hosts com mais de um papel (o
+ * financiamento tem boas-vindas + despedida) convergirem para este componente em vez de remontar
+ * a tela à parte.
+ */
+interface MessagesWorkspaceTemplateRole {
+    readonly key: string;
+    readonly labels: {
+        sectionTitle: string;
+        sectionDescription: string;
+    };
+    getSettings(): Promise<TemplateSettings>;
+    saveSettings(settings: TemplateSettings): Promise<void>;
+}
+interface TranscriptionSettings {
+    enabled: boolean;
+    mode: TranscriptionMode;
+    available: boolean;
+}
+interface MessagesWorkspaceApi {
+    getMessages(): Promise<BotMessages>;
+    saveMessages(messages: BotMessages): Promise<void>;
+    /** Sem este par, a seção de tópicos não é desenhada. */
+    getTopics?(): Promise<TopicItem[]>;
+    saveTopics?(topics: TopicItem[]): Promise<void>;
+    /** Sem este par, a aba de templates não é desenhada. */
+    getTemplateSettings?(): Promise<TemplateSettings>;
+    saveTemplateSettings?(settings: TemplateSettings): Promise<void>;
+    /** Papéis adicionais de template (ex.: despedida) além do principal acima. */
+    templateRoles?: MessagesWorkspaceTemplateRole[];
+    /**
+     * Lista de templates aprovados na Meta. Ausente, a aba ainda existe (dá para salvar o nome
+     * escolhido), mas nasce sem opções e sem botão de recarregar.
+     */
+    listTemplates?(): Promise<WhatsAppTemplateSummary[]>;
+    /** Sem isto, o submenu "Criar template" some. */
+    createTemplate?(input: WhatsAppCreateTemplateState): Promise<WhatsAppCreateTemplateResult>;
+    /** Sem este par, a aba de transcrição não é desenhada. */
+    getTranscription?(): Promise<TranscriptionSettings>;
+    saveTranscription?(settings: Omit<TranscriptionSettings, 'available'>): Promise<void>;
+}
+interface MessagesWorkspaceLabels {
+    title: string;
+    subtitle: string;
+    loading: string;
+    loadError: string;
+    tabBot: string;
+    tabTemplates: string;
+    tabTranscription: string;
+    welcomeFarewell: Partial<WelcomeFarewellFormLabels>;
+    topics: Partial<TopicsFormLabels>;
+    templates: Partial<WhatsAppTemplatesSettingsLabels>;
+    templateSettings: Partial<WhatsAppTemplateSettingsFormLabels>;
+    createTemplate: Partial<WhatsAppCreateTemplateFormLabels>;
+    transcription: Partial<TranscriptionSettingsFormLabels>;
+}
+interface MessagesWorkspaceProps {
+    readonly api: MessagesWorkspaceApi;
+    readonly labels?: Partial<MessagesWorkspaceLabels>;
+    readonly welcomePlaceholders?: readonly string[];
+    readonly farewellPlaceholders?: readonly string[];
+    readonly availableVariables?: WhatsAppTemplateVariableSuggestion[];
+    /** Aviso do produto acima da aba de templates (ex.: rota da Graph API ainda não implementada). */
+    readonly renderTemplatesNotice?: () => ReactNode;
+    /** Repassados ao formulário de criação — mesma prévia que `WhatsAppCreateTemplateForm` já suporta. */
+    readonly createTemplatePreviewCompanyName?: string;
+    readonly createTemplateVariableExamples?: readonly string[];
+    readonly className?: string;
+}
+declare function MessagesWorkspace({ api, labels: labelsOverride, welcomePlaceholders, farewellPlaceholders, availableVariables, renderTemplatesNotice, createTemplatePreviewCompanyName, createTemplateVariableExamples, className, }: MessagesWorkspaceProps): react.JSX.Element;
+
 interface UseConversationMessagesResult {
     messages: MessagePayload[];
     loading: boolean;
@@ -930,6 +1518,23 @@ declare function useConversationMessages(conversationId: string, params?: {
     before?: string;
 }): UseConversationMessagesResult;
 
+type UseScrollToLatestMessageParams = {
+    /** Troca de conversa. Muda ⇒ salto instantâneo para o fim. */
+    readonly conversationId: string | undefined;
+    /** Quantidade de mensagens carregadas. Cresce ⇒ acompanha o fim, se o operador estiver lá. */
+    readonly messageCount: number;
+};
+type UseScrollToLatestMessageResult = {
+    /** Vai no elemento que rola — tipicamente o `ConversationWallpaper`. */
+    readonly containerRef: RefObject<HTMLDivElement | null>;
+    /** Ligue no `onScroll` do mesmo elemento: é o que detecta o operador lendo o histórico. */
+    readonly handleScroll: (event: UIEvent<HTMLDivElement>) => void;
+    /** `true` quando o operador rolou para trás — serve a um botão "ir para a última". */
+    readonly isAwayFromBottom: boolean;
+    readonly scrollToBottom: (behavior?: ScrollBehavior) => void;
+};
+declare function useScrollToLatestMessage({ conversationId, messageCount, }: UseScrollToLatestMessageParams): UseScrollToLatestMessageResult;
+
 type UseConversationListParams = ListConversationsParams;
 interface UseConversationListResult {
     conversations: ConversationSummary[];
@@ -1017,4 +1622,301 @@ interface AsyncResourceState<T> {
 
 declare function createMediaUrlResolver(api: Pick<ConversationsApi, 'getDocumentUrl' | 'getMediaProxyUrl'>): ResolveMediaUrl;
 
-export { type AsyncResourceState, AudioPlayer, type AudioPlayerProps, Avatar, type AvatarLabels, type AvatarProps, type BuildTranscriptTextParams, CHANNEL_BRAND_COLOR, CONVERSATION_WINDOW, ChannelIcon, type ChannelIconProps, ConversationChannel, type ConversationContextEntry, ConversationContextPanel, type ConversationContextPanelClassNames, type ConversationContextPanelLabels, type ConversationContextPanelProps, ConversationDocument, ConversationDocumentsPanel, type ConversationDocumentsPanelClassNames, type ConversationDocumentsPanelLabels, type ConversationDocumentsPanelProps, ConversationHeader, type ConversationHeaderClassNames, type ConversationHeaderLabels, type ConversationHeaderProps, type ConversationHeaderUtility, ConversationListItem, type ConversationListItemLabels, type ConversationListItemProps, type ConversationLocales, ConversationLocalesProvider, type ConversationLocalesProviderProps, type ConversationRealtimeHandler, ConversationRow, type ConversationRowClassNames, type ConversationRowProps, ConversationSummary, ConversationTemplate, ConversationWallpaper, type ConversationWallpaperProps, type ConversationWindow, ConversationsApi, ConversationsFeatures, ConversationsProvider, DEFAULT_ACCEPTED_FILE_TYPES, DEFAULT_AVATAR_LABELS, DEFAULT_CONVERSATION_CONTEXT_LABELS, DEFAULT_CONVERSATION_DOCUMENTS_LABELS, DEFAULT_CONVERSATION_HEADER_LABELS, DEFAULT_CONVERSATION_LIST_ITEM_LABELS, DEFAULT_DOCUMENTS_LIBRARY_LABELS, DEFAULT_EMOJI_PICKER_LABELS, DEFAULT_INTERACTIVE_MESSAGE_LABELS, DEFAULT_LIGHTBOX_LABELS, DEFAULT_MESSAGE_COMPOSER_LABELS, DEFAULT_TEMPLATES_SETTINGS_LABELS, DEFAULT_WHATSAPP_MESSAGE_EDITOR_LABELS, DEFAULT_WINDOW_EXPIRED_LABELS, DOCUMENT_SOURCE_FILTER, DateDivider, type DateDividerClassNames, type DateDividerProps, type DocumentSourceFilter, DocumentsLibrary, type DocumentsLibraryClassNames, type DocumentsLibraryLabels, type DocumentsLibraryProps, EMOJI_CATEGORIES, type EmojiCategory, type EmojiEntry, EmojiPicker, type EmojiPickerLabels, type EmojiPickerProps, FileIcon, type FileIconProps, InteractiveMessage, type InteractiveMessageLabels, type InteractiveMessageProps, InteractivePayload, InteractiveSelection, Lightbox, type LightboxLabels, type LightboxProps, ListConversationsParams, ListDocumentsParams, MessageBubble, type MessageBubbleProps, MessageComposer, type MessageComposerClassNames, type MessageComposerLabels, type MessageComposerProps, MessagePayload, MessageTail, MessageText, type MessageTextProps, MessageTimestamp, NARROW_MAX_WIDTH_PX, ResolveMediaUrl, SSEProvider, SimpleEmojiPicker, type SimpleEmojiPickerProps, StatusTicks, type StatusTicksProps, TEMPLATE_SETTINGS_TAB, type TemplateSettingsTab, ToastProvider, type TopicItem, TopicsForm, type TopicsFormLabels, type TopicsFormProps, type UseConversationActionsResult, type UseConversationContextResult, type UseConversationDocumentsParams, type UseConversationDocumentsResult, type UseConversationListParams, type UseConversationListResult, type UseConversationMessagesResult, type UseInboxActionsResult, type UseWaitingNotificationsLabels, type UseWaitingNotificationsParams, type UseWaitingNotificationsResult, WINDOW_FILTERS, WelcomeFarewellForm, type WelcomeFarewellFormLabels, type WelcomeFarewellFormProps, WhatsAppCreateTemplateForm, type WhatsAppCreateTemplateFormLabels, type WhatsAppCreateTemplateFormProps, type WhatsAppCreateTemplateResult, type WhatsAppCreateTemplateState, WhatsAppMessageEditor, type WhatsAppMessageEditorLabels, type WhatsAppMessageEditorProps, type WhatsAppTemplateHeaderType, WhatsAppTemplateSettingsForm, type WhatsAppTemplateSettingsFormLabels, type WhatsAppTemplateSettingsFormProps, type WhatsAppTemplateSummary, type WhatsAppTemplateVariableSuggestion, WhatsAppTemplatesSettings, type WhatsAppTemplatesSettingsLabels, type WhatsAppTemplatesSettingsProps, WindowExpiredNotice, type WindowExpiredNoticeLabels, type WindowExpiredNoticeProps, type WindowOfParams, buildTranscriptFilename, buildTranscriptText, createMediaUrlResolver, downloadTextFile, formatDateTime, formatFileSize, formatPhone, formatStalledFor, formatTimestamp, htmlToWA, isSameDay, isWindowBlocking, parseWhatsAppFormatting, phoneInitials, searchEmojis, toast, useConversationActions, useConversationContext, useConversationDocuments, useConversationList, useConversationLocales, useConversationMessages, useConversationRealtime, useConversations, useDarkMode, useGlobalRealtime, useInboxActions, useIsDarkTheme, useIsNarrow, useToast, useWaitingNotifications, waToHTML, waToHTMLInline, windowOf };
+/**
+ * Textos da inbox. Todos sobrescrevíveis: o produto troca vocabulário ("cliente" vira "lead") ou
+ * o idioma inteiro sem tocar no layout — e sem manter uma cópia da tela para isso.
+ */
+interface ConversationsWorkspaceLabels {
+    readonly title: string;
+    readonly conversations: string;
+    readonly waiting: string;
+    readonly unread: string;
+    readonly waitingOnly: string;
+    readonly markSelectedAsRead: string;
+    readonly search: string;
+    readonly windowLegend: string;
+    readonly channelLegend: string;
+    readonly selectAll: string;
+    readonly emptyList: string;
+    readonly emptyDetail: string;
+    readonly bulkSelected: (count: number) => string;
+    readonly bulkClear: string;
+    readonly bulkFinalize: string;
+    readonly bulkFinalizeConfirm: (count: number) => string;
+    readonly bulkTemplate: string;
+    readonly markAllAsRead: string;
+    readonly templateModalTitle: string;
+    readonly templateModalSearch: string;
+    readonly templateModalEmpty: string;
+    readonly templateModalCancel: string;
+    readonly templateModalSending: string;
+    readonly templateModalNoneExpired: string;
+    readonly templateModalAvailable: (count: number) => string;
+    readonly templateModalSend: (count: number) => string;
+    readonly messagesSelected: (count: number) => string;
+    readonly copySelected: string;
+    readonly composerPlaceholder: string;
+    readonly attachFailure: string;
+    /** Tira um arquivo da fila antes de enviar. */
+    readonly attachmentRemove: string;
+    readonly recordFailure: string;
+    readonly sendFailure: string;
+    readonly takeoverToReply: string;
+    readonly signIn: string;
+    readonly pageOf: (page: number, pageCount: number) => string;
+    readonly rangeOf: (first: number, last: number, total: number) => string;
+}
+declare const DEFAULT_CONVERSATIONS_WORKSPACE_LABELS: ConversationsWorkspaceLabels;
+
+/**
+ * Estado da inbox: filtros, paginação, seleção em massa e ações de atendimento.
+ *
+ * Nasceu igual em três produtos e divergiu em três — contadores diferentes, um marcava lida ao
+ * abrir e outro não, um perdia a página ao trocar de filtro. É a lógica de operar uma inbox, não
+ * regra de nenhum negócio, e por isso mora aqui.
+ *
+ * A paginação é do cliente porque nem todo backend pagina a listagem. Fatiar aqui mantém a tela
+ * utilizável com centenas de conversas; com dezenas de milhares o gargalo volta e a resposta é
+ * paginar no servidor.
+ */
+
+declare const CONVERSATIONS_PER_PAGE = 50;
+interface UseConversationsInboxParams {
+    /** Recortes do produto repassados crus ao backend dele (carteira, campanha, tipo). */
+    readonly filters?: Record<string, string | undefined>;
+    readonly perPage?: number;
+    /**
+     * Marca como lida a conversa aberta. Ligado por padrão: badge subindo na conversa que o atendente
+     * tem na frente é ruído que ele não tem como resolver.
+     */
+    readonly markReadOnOpen?: boolean;
+    /**
+     * Pede a página ao servidor em vez de fatiar o que veio. Necessário quando a base é grande — o
+     * padrão traz tudo e pagina no cliente porque nem todo backend pagina a listagem.
+     */
+    readonly serverPaginated?: boolean;
+    readonly describeFailure?: (error: unknown) => string;
+}
+interface UseConversationsInboxResult {
+    readonly conversations: readonly ConversationSummary[];
+    readonly pageConversations: readonly ConversationSummary[];
+    readonly selectedConversation: ConversationSummary | undefined;
+    readonly loading: boolean;
+    readonly now: number;
+    readonly totalCount: number;
+    readonly unreadCount: number;
+    readonly waitingCount: number;
+    readonly filteredCount: number;
+    /** Selecionadas fora da janela de 24h — as únicas que um template alcança. */
+    readonly expiredSelectedCount: number;
+    readonly page: number;
+    readonly pageCount: number;
+    readonly firstOnPage: number;
+    readonly lastOnPage: number;
+    readonly selectedId: string | undefined;
+    readonly selectedIds: ReadonlySet<string>;
+    readonly allOnPageSelected: boolean;
+    readonly waitingOnly: boolean;
+    readonly windowFilter: ConversationWindow;
+    readonly channelFilter: ChannelFilter;
+    readonly channelFilters: readonly ChannelFilterOption[];
+    readonly search: string;
+    readonly busy: boolean;
+    /** Por que a lista está vazia, quando não é por não haver conversa. */
+    readonly loadFailure: string | undefined;
+    /** Ausentes quando o host não implementa a capacidade — a UI não desenha a afordância. */
+    readonly canTakeover: boolean;
+    readonly canFinalize: boolean;
+    readonly canListTemplates: boolean;
+    readonly canMarkAllRead: boolean;
+    refetch(): Promise<void> | void;
+    selectConversation(conversationId: string): void;
+    clearSelection(): void;
+    toggleSelected(conversationId: string): void;
+    toggleSelectAllOnPage(): void;
+    clearBulkSelection(): void;
+    setWaitingOnly(value: boolean): void;
+    setWindowFilter(value: ConversationWindow): void;
+    setChannelFilter(value: ChannelFilter): void;
+    setSearch(value: string): void;
+    goToPage(value: number): void;
+    markSelectedAsRead(): Promise<void>;
+    markAllAsRead(): Promise<void>;
+    takeover(conversationId: string): Promise<void>;
+    releaseToBot(conversationId: string): Promise<void>;
+    finalize(conversationId: string): Promise<void>;
+    finalizeSelected(): Promise<void>;
+    sendTemplateToSelected(templateName?: string): Promise<void>;
+}
+declare function useConversationsInbox(params?: UseConversationsInboxParams): UseConversationsInboxResult;
+
+type SimulatorTransportParams = {
+    readonly conversationId: string;
+    readonly channel: ConversationChannel;
+    /** Identificador do contato no canal: telefone no WhatsApp, id de sessão no chat do site. */
+    readonly handle: string;
+};
+/**
+ * Fábrica do transporte daquele canal.
+ *
+ * É o único ponto onde o host precisa saber de canal: o painel, a moldura e o comportamento são os
+ * mesmos em todos. No WhatsApp devolve o cliente-ponte (assinatura no servidor do host); no chat do
+ * site, o cliente das rotas do widget.
+ */
+type SimulatorTransportFactory = (params: SimulatorTransportParams) => ConversationSimulatorClient;
+interface ConversationsWorkspaceSimulator {
+    /**
+     * Um transporte por canal — o workspace monta o painel com o da conversa selecionada.
+     *
+     * Canal sem transporte não desenha o botão: capacidade é opcional por ausência, e oferecer
+     * "simular" numa conversa que não tem como receber a mensagem é um botão que falha ao ser tocado.
+     */
+    readonly transports?: Partial<Record<ConversationChannel, SimulatorTransportFactory>>;
+    /**
+     * Válvula de escape: o host desenha o painel inteiro. Tem precedência sobre `transports`.
+     *
+     * Era a única porta antes de `transports`, quando o simulador só falava WhatsApp e cada produto
+     * remontava a moldura — o que fez duas telas da mesma casa divergirem. Continua aceito para não
+     * quebrar quem já a usa.
+     */
+    render?(params: {
+        conversationId: string;
+        channel: ConversationChannel;
+        close: () => void;
+    }): ReactNode;
+    /** Ausente = ligado. Serve para esconder fora de desenvolvimento sem condicionar o JSX. */
+    readonly enabled?: boolean;
+    /** Ícone da biblioteca (lucide) no utilitário do cabeçalho. Ausente, entra o frasco de teste. */
+    readonly icon?: ReactNode;
+    readonly label?: string;
+    /** Vocabulário do painel. O que muda de canal (destino, placeholder) já vem resolvido. */
+    readonly labels?: Partial<ConversationSimulatorPanelLabels>;
+    /** Destino do upload no canal que entrega mídia por referência (o caminho da Meta). */
+    readonly uploadMedia?: (file: File) => Promise<PreviewUploadedMedia>;
+    /** Recarrega o transcript a cada N ms. Serve a host sem stream. */
+    readonly pollIntervalMs?: number;
+}
+interface ConversationsWorkspaceProps {
+    readonly labels?: Partial<ConversationsWorkspaceLabels>;
+    readonly filters?: Record<string, string | undefined>;
+    readonly perPage?: number;
+    readonly markReadOnOpen?: boolean;
+    /** Pede a página ao servidor em vez de fatiar no cliente. */
+    readonly serverPaginated?: boolean;
+    /** Conversa a abrir na montagem (deep link `?id=`). */
+    readonly initialConversationId?: string | undefined;
+    /** Idem, pelo telefone — é o que costuma vir no link de um alerta ou de um pedido. */
+    readonly initialWhatsappNumber?: string | undefined;
+    readonly simulator?: ConversationsWorkspaceSimulator;
+    readonly quickReplies?: readonly QuickReply[];
+    readonly quickReplyVariablesFor?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => Record<string, string>;
+    /** Etapa do fluxo mostrada no painel de contexto. */
+    readonly flowLabelOf?: (conversation: ConversationSummary) => string | undefined;
+    /** Substitui o download local do transcript (ex.: exportação completa pela rota do servidor). */
+    readonly onDownload?: (conversation: ConversationSummary) => void;
+    /** Bloqueia o composer enquanto a conversa estiver com o bot. */
+    readonly requireTakeoverToReply?: boolean;
+    /** Deixa marcar mensagens no transcript e copiar o trecho. */
+    readonly messageSelection?: boolean;
+    /** Texto já no campo ao abrir a conversa (deep link que sugere a resposta). */
+    readonly initialComposerText?: string | undefined;
+    /** `rich` troca o campo simples pelo texto com a formatação do WhatsApp desenhada ao escrever. */
+    readonly composer?: 'simple' | 'rich';
+    /** Valores que o operador insere sem digitar. Só o composer `rich` os oferece. */
+    readonly composerVariablesFor?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => readonly RichComposerVariable[];
+    /** Fila de anexos com legenda, como no WhatsApp. Ausente, o clipe manda cada arquivo na hora. */
+    readonly onSendAttachments?: (conversation: ConversationSummary, files: readonly File[], caption: string) => Promise<void>;
+    /** Nota de voz. Ausente, o microfone não aparece. */
+    readonly onRecordAudio?: (conversation: ConversationSummary, file: File) => Promise<void>;
+    readonly contextEntriesOf?: (context: Record<string, unknown> | undefined) => readonly ConversationContextEntry[];
+    readonly onAttach?: (conversation: ConversationSummary, file: File) => Promise<void>;
+    readonly extraUtilitiesFor?: (conversation: ConversationSummary) => readonly ConversationHeaderUtility[];
+    readonly renderFilters?: (inbox: UseConversationsInboxResult) => ReactNode;
+    readonly renderBulkActions?: (inbox: UseConversationsInboxResult) => ReactNode;
+    readonly renderRow?: (conversation: ConversationSummary) => ReactNode;
+    readonly renderAboveTranscript?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => ReactNode;
+    readonly renderHeaderActions?: (inbox: UseConversationsInboxResult) => ReactNode;
+    readonly onSendTemplateToSelected?: (inbox: UseConversationsInboxResult) => void;
+    /** Destino do link de reentrar no painel, mostrado junto do aviso de sessão expirada. */
+    readonly signInHref?: string;
+    readonly className?: string;
+}
+declare function ConversationsWorkspace({ labels: labelsOverride, filters, perPage, markReadOnOpen, serverPaginated, initialConversationId, initialWhatsappNumber, simulator, quickReplies, quickReplyVariablesFor, flowLabelOf, onDownload, requireTakeoverToReply, messageSelection, initialComposerText, composer, composerVariablesFor, onSendAttachments, onRecordAudio, contextEntriesOf, onAttach, extraUtilitiesFor, renderFilters, renderBulkActions, renderRow, renderAboveTranscript, renderHeaderActions, onSendTemplateToSelected, signInHref, className, }: ConversationsWorkspaceProps): react.JSX.Element;
+
+interface ConversationPaneProps {
+    readonly conversation: ConversationSummary;
+    readonly now: number;
+    readonly busy: boolean;
+    readonly labels: ConversationsWorkspaceLabels;
+    /** Devolve a promessa quando o host a tem: o envio de template espera a tomada antes de sair. */
+    readonly onTakeover?: (() => void | Promise<void>) | undefined;
+    readonly onReturnToBot?: (() => void) | undefined;
+    readonly onFinish?: (() => void) | undefined;
+    readonly onBack: () => void;
+    readonly extraUtilities?: readonly ConversationHeaderUtility[];
+    /** Traduz o contexto cru do produto nas linhas do painel. Ausente, o painel não aparece. */
+    readonly contextEntriesOf?: (context: Record<string, unknown> | undefined) => readonly ConversationContextEntry[];
+    readonly quickReplies?: readonly QuickReply[];
+    /**
+     * Recebe o contexto junto porque o dado que interessa à variável (o nome que o bot perguntou,
+     * por exemplo) vive no contexto do fluxo, não no resumo da listagem.
+     */
+    readonly quickReplyVariablesFor?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => Record<string, string>;
+    /** Etapa do fluxo ao lado do contexto (ex.: "Anotando o pedido"). */
+    readonly flowLabel?: string | undefined;
+    /**
+     * Substitui o download local do transcript. Existe para o produto que exporta pela rota do
+     * servidor, onde o arquivo sai completo em vez de só com o que a tela carregou.
+     */
+    readonly onDownload?: (() => void) | undefined;
+    /**
+     * Bloqueia o composer enquanto a conversa estiver com o bot. Ligado, responder sem assumir
+     * atropelaria o fluxo automático no meio de uma pergunta.
+     */
+    readonly requireTakeoverToReply?: boolean;
+    /**
+     * Deixa marcar mensagens e copiar o trecho. É o que se faz para levar um pedaço da conversa a um
+     * e-mail ou a um chamado, sem baixar o transcript inteiro.
+     */
+    readonly messageSelection?: boolean;
+    /** Texto já no campo ao abrir (deep link que sugere a resposta). */
+    readonly initialComposerText?: string | undefined;
+    /**
+     * Peça do produto entre o contexto e o transcript (ex.: ficha do lead, resumo do pedido). Recebe o
+     * contexto do fluxo junto: é dele que sai o resumo, e sem isso o host teria de buscá-lo de novo.
+     */
+    readonly renderAboveTranscript?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => ReactNode;
+    readonly onAttach?: ((file: File) => Promise<void>) | undefined;
+    /**
+     * `rich` troca o `textarea` pelo campo com a formatação do WhatsApp desenhada enquanto se escreve.
+     * Vale onde o atendente manda texto longo e formatado; para responder "já vou ver" o campo simples
+     * é menos coisa na tela.
+     */
+    readonly composer?: 'simple' | 'rich';
+    /** Valores que o operador insere sem digitar. Só o composer `rich` os oferece. */
+    readonly composerVariablesFor?: (conversation: ConversationSummary, context: Record<string, unknown> | undefined) => readonly RichComposerVariable[];
+    /**
+     * Fila de anexos com legenda, como no WhatsApp: os arquivos escolhidos ficam visíveis acima da
+     * barra e saem junto com o texto escrito. Ausente, o clipe manda cada arquivo na hora — o que
+     * perde a legenda, e era a diferença entre as telas.
+     */
+    readonly onSendAttachments?: (files: readonly File[], caption: string) => Promise<void>;
+    /** Grava e envia nota de voz. Ausente, o microfone não aparece. */
+    readonly onRecordAudio?: (file: File) => Promise<void>;
+}
+declare function ConversationPane({ conversation, now, busy, labels, onTakeover, onReturnToBot, onFinish, onBack, extraUtilities, contextEntriesOf, quickReplies, quickReplyVariablesFor, flowLabel, onDownload, requireTakeoverToReply, messageSelection, initialComposerText, renderAboveTranscript, onAttach, composer, composerVariablesFor, onSendAttachments, onRecordAudio, }: ConversationPaneProps): react.JSX.Element;
+
+interface ConversationsInboxListProps {
+    readonly inbox: UseConversationsInboxResult;
+    readonly labels: ConversationsWorkspaceLabels;
+    readonly className?: string;
+    /** Barra extra do produto acima da lista (ex.: filtro de carteira, seletor de campanha). */
+    readonly renderFilters?: (inbox: UseConversationsInboxResult) => ReactNode;
+    /** Ações em lote do produto, ao lado de finalizar e template. */
+    readonly renderBulkActions?: (inbox: UseConversationsInboxResult) => ReactNode;
+    readonly renderRow?: (conversation: ConversationSummary) => ReactNode;
+    readonly onSendTemplateToSelected?: () => void;
+}
+declare function ConversationsInboxList({ inbox, labels, className, renderFilters, renderBulkActions, renderRow, onSendTemplateToSelected, }: ConversationsInboxListProps): react.JSX.Element;
+
+export { type AsyncResourceState, AudioPlayer, type AudioPlayerProps, AudioTranscription, type AudioTranscriptionProps, Avatar, type AvatarLabels, type AvatarProps, type BotMessages, type BuildTranscriptTextParams, BulkActionBar, type BulkActionBarProps, CHANNEL_BRAND_COLOR, CONVERSATIONS_PER_PAGE, CONVERSATION_WINDOW, ChannelFilter, ChannelFilterOption, ChannelIcon, type ChannelIconProps, ConversationChannel, type ConversationContextEntry, ConversationContextPanel, type ConversationContextPanelClassNames, type ConversationContextPanelLabels, type ConversationContextPanelProps, type ConversationContextStatus, ConversationDocument, ConversationDocumentsPanel, type ConversationDocumentsPanelClassNames, type ConversationDocumentsPanelLabels, type ConversationDocumentsPanelProps, ConversationHeader, type ConversationHeaderClassNames, type ConversationHeaderLabels, type ConversationHeaderProps, type ConversationHeaderUtility, ConversationListItem, type ConversationListItemLabels, type ConversationListItemProps, type ConversationLocales, ConversationLocalesProvider, type ConversationLocalesProviderProps, ConversationPane, type ConversationPaneProps, type ConversationRealtimeHandler, ConversationRow, type ConversationRowClassNames, type ConversationRowProps, ConversationSimulatorClient, ConversationSummary, ConversationTemplate, ConversationWallpaper, type ConversationWallpaperProps, type ConversationWindow, ConversationsApi, ConversationsFeatures, ConversationsInboxList, type ConversationsInboxListProps, ConversationsProvider, ConversationsWorkspace, type ConversationsWorkspaceLabels, type ConversationsWorkspaceProps, type ConversationsWorkspaceSimulator, DEFAULT_ACCEPTED_FILE_TYPES, DEFAULT_AVATAR_LABELS, DEFAULT_CONVERSATIONS_WORKSPACE_LABELS, DEFAULT_CONVERSATION_CONTEXT_LABELS, DEFAULT_CONVERSATION_DOCUMENTS_LABELS, DEFAULT_CONVERSATION_HEADER_LABELS, DEFAULT_CONVERSATION_LIST_ITEM_LABELS, DEFAULT_DARK_MODE_TOGGLE_LABELS, DEFAULT_DOCUMENTS_LIBRARY_LABELS, DEFAULT_DOCUMENTS_WORKSPACE_LABELS, DEFAULT_EMOJI_PICKER_LABELS, DEFAULT_INTERACTIVE_MESSAGE_LABELS, DEFAULT_LIGHTBOX_LABELS, DEFAULT_MESSAGE_COMPOSER_LABELS, DEFAULT_RICH_COMPOSER_TOOLTIPS, DEFAULT_TEMPLATES_SETTINGS_LABELS, DEFAULT_WHATSAPP_MESSAGE_EDITOR_LABELS, DEFAULT_WINDOW_EXPIRED_LABELS, DOCUMENT_SOURCE_FILTER, DarkModeToggle, type DarkModeToggleLabels, type DarkModeToggleProps, DateDivider, type DateDividerClassNames, type DateDividerProps, type DocumentSourceFilter, type DocumentsFiltersContext, DocumentsLibrary, type DocumentsLibraryClassNames, type DocumentsLibraryLabels, type DocumentsLibraryProps, DocumentsWorkspace, type DocumentsWorkspaceClassNames, type DocumentsWorkspaceLabels, type DocumentsWorkspaceProps, EMOJI_CATEGORIES, type EmojiCategory, type EmojiEntry, EmojiPicker, type EmojiPickerLabels, type EmojiPickerProps, FileIcon, type FileIconProps, type FilterOption, InteractiveMessage, type InteractiveMessageLabels, type InteractiveMessageProps, InteractivePayload, InteractiveSelection, Lightbox, type LightboxLabels, type LightboxProps, ListConversationsParams, ListDocumentsParams, ListingPagination, type ListingPaginationProps, MessageBubble, type MessageBubbleProps, MessageComposer, type MessageComposerClassNames, type MessageComposerLabels, type MessageComposerProps, MessagePayload, MessageTail, MessageText, type MessageTextProps, MessageTimestamp, MessageTranscription, MessagesWorkspace, type MessagesWorkspaceApi, type MessagesWorkspaceLabels, type MessagesWorkspaceProps, type MessagesWorkspaceTemplateRole, MultiSelectFilter, type MultiSelectFilterProps, NARROW_MAX_WIDTH_PX, type QuickReply, REPLY_LATENCY, REPLY_LATENCY_CRITICAL_HOURS, REPLY_LATENCY_LATE_HOURS, RICH_COMPOSER_ACTION, type ReplyLatency, type ReplyLatencyParams, ResolveMediaUrl, type RichComposerAction, type RichComposerQuickReply, type RichComposerTooltips, type RichComposerVariable, RichMessageComposer, type RichMessageComposerHandle, type RichMessageComposerProps, SSEProvider, SimpleEmojiPicker, type SimpleEmojiPickerProps, type SimulatorTransportFactory, type SimulatorTransportParams, type SortDirection, SortableHead, type SortableHeadProps, StatusTicks, type StatusTicksProps, TEMPLATE_SETTINGS_TAB, TOOLTIP_ATTRIBUTE, type TemplateSettings, type TemplateSettingsTab, ToastProvider, TooltipLayer, type TopicItem, TopicsForm, type TopicsFormLabels, type TopicsFormProps, TranscriptionMode, type TranscriptionSettings, TranscriptionSettingsForm, type TranscriptionSettingsFormLabels, type TranscriptionSettingsFormProps, type UrlStateOptions, type UseConversationActionsResult, type UseConversationContextResult, type UseConversationDocumentsParams, type UseConversationDocumentsResult, type UseConversationListParams, type UseConversationListResult, type UseConversationMessagesResult, type UseConversationsInboxParams, type UseConversationsInboxResult, type UseInboxActionsResult, type UseScrollToLatestMessageParams, type UseScrollToLatestMessageResult, type UseWaitingNotificationsLabels, type UseWaitingNotificationsParams, type UseWaitingNotificationsResult, WINDOW_FILTERS, WelcomeFarewellForm, type WelcomeFarewellFormLabels, type WelcomeFarewellFormProps, WhatsAppCreateTemplateForm, type WhatsAppCreateTemplateFormLabels, type WhatsAppCreateTemplateFormProps, type WhatsAppCreateTemplateResult, type WhatsAppCreateTemplateState, WhatsAppMessageEditor, type WhatsAppMessageEditorLabels, type WhatsAppMessageEditorProps, type WhatsAppTemplateHeaderType, WhatsAppTemplateSettingsForm, type WhatsAppTemplateSettingsFormLabels, type WhatsAppTemplateSettingsFormProps, type WhatsAppTemplateSummary, type WhatsAppTemplateVariableSuggestion, WhatsAppTemplatesSettings, type WhatsAppTemplatesSettingsLabels, type WhatsAppTemplatesSettingsProps, WindowExpiredNotice, type WindowExpiredNoticeLabels, type WindowExpiredNoticeProps, type WindowOfParams, applyQuickReplyVariables, buildTranscriptFilename, buildTranscriptText, createMediaUrlResolver, downloadTextFile, formatDateTime, formatFileSize, formatPhone, formatStalledFor, formatTimestamp, htmlToWA, isReplyOverdue, isSameDay, isWindowBlocking, parseWhatsAppFormatting, phoneInitials, replyLatencyOf, resolveQuickReply, searchEmojis, toast, useConversationActions, useConversationContext, useConversationDocuments, useConversationList, useConversationLocales, useConversationMessages, useConversationRealtime, useConversations, useConversationsInbox, useDarkMode, useDebouncedValue, useGlobalRealtime, useInboxActions, useIsDarkTheme, useIsNarrow, useScrollToLatestMessage, useToast, useUrlArrayState, useUrlNumberState, useUrlStringState, useWaitingNotifications, waToHTML, waToHTMLInline, windowOf };