@adatechnology/conversations-ui 0.1.0-rc.4 → 0.1.0-rc.41

package/dist/index.d.ts

@@ -1,15 +1,8 @@
 import * as react from 'react';
-import react__default, { ReactNode, FormEvent } from 'react';
-import { M as MessagePayload, k as ConversationsFeatures, i as ConversationSummary, f as ConversationChannel, j as ConversationsApi, S as SSEProvider, g as ConversationDocument } from './types-C0PtaO7S.js';
-export { C as CHANNEL_CAPABILITIES, a as CHANNEL_FILTER_ALL, b as CONVERSATION_CHANNEL, c as ChannelCapabilities, d as ChannelFilter, e as ChannelFilterOption, h as ConversationEventSource, l as ConversationsTheme, m as ConversationsUIConfig, D as DEFAULT_CONVERSATION_CHANNEL, F as FormatContactHandleParams, H as HANDLE_KIND, n as HandleKind, R as REOPEN_MECHANISM, o as ReopenMechanism, p as capabilitiesOf, q as channelFiltersFor, r as contactFlag, s as formatContactHandle } from './types-C0PtaO7S.js';
-
-type ResolveMediaUrl = (message: MessagePayload) => Promise<string | null>;
-interface MediaRendererProps {
-    message: MessagePayload;
-    onLightbox: (src: string) => void;
-    onResolveUrl?: ResolveMediaUrl;
-}
-declare function MediaRenderer({ message, onLightbox, onResolveUrl }: MediaRendererProps): react.JSX.Element | null;
+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;
@@ -19,16 +12,56 @@ interface MessageBubbleProps {
     isSelecting?: boolean;
     isSelected?: boolean;
     onToggleSelect?: () => void;
+    /**
+     * Como buscar a mídia da mensagem. Ausente, o balão usa o `ConversationsApi` do
+     * `ConversationsProvider` — passe apenas para sobrescrever (cache próprio, CDN, proxy do host).
+     */
     onResolveMediaUrl?: ResolveMediaUrl;
+    /**
+     * Toque numa opção do menu interativo. Ausente, as opções aparecem desabilitadas — que é o certo
+     * 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, 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. */
+    openList: string;
+}
+declare const DEFAULT_INTERACTIVE_MESSAGE_LABELS: InteractiveMessageLabels;
+interface InteractiveMessageProps {
+    payload: InteractivePayload;
+    onSelect?: (selection: InteractiveSelection) => void;
+    labels?: Partial<InteractiveMessageLabels>;
+    className?: string;
+}
+declare function InteractiveMessage({ payload, onSelect, labels, className }: InteractiveMessageProps): react.JSX.Element;
 
 interface ConversationWallpaperProps {
     children?: ReactNode;
     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 }: 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: {
@@ -52,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;
     };
@@ -76,13 +123,97 @@ 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;
+}
+declare const DEFAULT_EMOJI_PICKER_LABELS: EmojiPickerLabels;
 interface EmojiPickerProps {
     onSelect: (emoji: string) => void;
+    labels?: Partial<EmojiPickerLabels>;
     className?: string;
 }
-declare const EmojiPicker: ({ onSelect, className }: EmojiPickerProps) => react.JSX.Element;
+declare const EmojiPicker: ({ onSelect, labels, className }: EmojiPickerProps) => react.JSX.Element;
 
+/**
+ * Catálogo de emojis com palavras-chave em português, usado pela busca do seletor.
+ *
+ * Fica em módulo próprio (e não dentro do `EmojiPicker`) porque a busca precisa varrer TODAS as
+ * categorias, não só a aberta — o índice é montado uma vez, no carregamento, e não a cada tecla.
+ *
+ * As palavras-chave são de busca, não legendas: incluem sinônimos e formas sem acento, porque quem
+ * digita rápido escreve "coracao" e "polegar" com a mesma frequência que a forma correta.
+ */
+type EmojiEntry = {
+    readonly emoji: string;
+    readonly keywords: readonly string[];
+};
+type EmojiCategory = {
+    readonly name: string;
+    readonly entries: readonly EmojiEntry[];
+};
+declare const EMOJI_CATEGORIES: readonly EmojiCategory[];
+/**
+ * Busca por prefixo de palavra-chave, não por substring: "ca" traz "casa" e "cartão", mas "sa" não
+ * traz "casa" — casar no meio da palavra devolvia resultado que ninguém consegue explicar.
+ */
+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 {
+    labels?: Partial<MessageComposerLabels>;
     onSend: (text: string) => void;
     onAttach?: (file: File) => void;
     value?: string;
@@ -92,16 +223,130 @@ 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;
 }
-declare const MessageComposer: ({ onSend, onAttach, value: externalValue, onChange: externalOnChange, features, placeholder, maxLength, disabled, acceptedFileTypes, className, classNames, }: MessageComposerProps) => react.JSX.Element;
+/**
+ * Exatamente o que a Meta aceita em mensagem de mídia — imagem, sticker, áudio, vídeo e a lista
+ * fechada de documentos. Oferecer no seletor um formato que o WhatsApp recusa (`.zip`, `.rtf`)
+ * empurra a falha para depois do envio, quando já não dá para explicar ao operador o que houve.
+ * Produto com regra própria passa `acceptedFileTypes`.
+ */
+declare const DEFAULT_ACCEPTED_FILE_TYPES: string;
+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;
+    /** Tooltip da negrito — traz a sintaxe do WhatsApp junto, por isso é separado do `aria-label`. */
+    boldHint: string;
+    italic: string;
+    italicHint: string;
+    strikethrough: string;
+    strikethroughHint: string;
+    insertPlaceholder: (token: string) => string;
+}
+declare const DEFAULT_WHATSAPP_MESSAGE_EDITOR_LABELS: WhatsAppMessageEditorLabels;
 interface WhatsAppMessageEditorProps {
+    labels?: Partial<WhatsAppMessageEditorLabels>;
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
@@ -110,7 +355,7 @@ interface WhatsAppMessageEditorProps {
     previewLabel?: string;
     emptyPreviewText?: string;
 }
-declare function WhatsAppMessageEditor({ value, onChange, placeholder, placeholders, rows, previewLabel, emptyPreviewText, }: WhatsAppMessageEditorProps): react.JSX.Element;
+declare function WhatsAppMessageEditor({ value, onChange, placeholder, placeholders, rows, previewLabel, emptyPreviewText, labels, }: WhatsAppMessageEditorProps): react.JSX.Element;
 
 interface SimpleEmojiPickerProps {
     onSelect: (emoji: string) => void;
@@ -131,16 +376,30 @@ interface DateDividerProps {
 }
 declare function DateDivider({ iso, className, classNames }: DateDividerProps): react.JSX.Element;
 
+interface AvatarLabels {
+    /** Lido por leitor de tela quando não há nome nem imagem — a silhueta genérica. */
+    unnamedContact: string;
+}
 interface AvatarProps {
     name?: string | null;
     avatarUrl?: string;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    labels?: Partial<AvatarLabels>;
 }
-declare function Avatar({ name, avatarUrl, size, className }: AvatarProps): react.JSX.Element;
+declare const DEFAULT_AVATAR_LABELS: AvatarLabels;
+declare function Avatar({ name, avatarUrl, size, className, labels }: AvatarProps): react.JSX.Element;
 
+interface ConversationListItemLabels {
+    /** Tooltip do ponto vermelho: a janela de atendimento de 24h já fechou. */
+    expiredWindow: string;
+    /** Tooltip do ponto laranja: a janela de atendimento está perto de fechar. */
+    warningWindow: string;
+}
+declare const DEFAULT_CONVERSATION_LIST_ITEM_LABELS: ConversationListItemLabels;
 interface ConversationListItemProps {
     conversation: ConversationSummary;
+    labels?: Partial<ConversationListItemLabels>;
     active?: boolean;
     selected?: boolean;
     onClick?: () => void;
@@ -157,7 +416,7 @@ interface ConversationListItemProps {
      */
     highlightActive?: boolean;
 }
-declare const ConversationListItem: ({ conversation, active, selected, onClick, onSelect, showDivider, highlightActive, }: ConversationListItemProps) => react.JSX.Element;
+declare const ConversationListItem: ({ conversation, active, selected, onClick, onSelect, showDivider, highlightActive, labels, }: ConversationListItemProps) => react.JSX.Element;
 
 type ToastType = 'success' | 'error' | 'info';
 interface ToastContextValue {
@@ -171,18 +430,41 @@ 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;
 }
 declare function StatusTicks({ status, title }: StatusTicksProps): react.JSX.Element;
 
+interface LightboxLabels {
+    /** Texto alternativo quando a imagem não tem legenda — sem ele o leitor de tela anuncia a URL. */
+    imageAlt: string;
+    close: string;
+}
 interface LightboxProps {
     imageUrl: string;
     caption?: string;
     onClose: () => void;
+    labels?: Partial<LightboxLabels>;
 }
-declare function Lightbox({ imageUrl, caption, onClose }: LightboxProps): react.JSX.Element;
+declare const DEFAULT_LIGHTBOX_LABELS: LightboxLabels;
+declare function Lightbox({ imageUrl, caption, onClose, labels }: LightboxProps): react.JSX.Element;
 
 interface FileIconProps {
     filename?: string;
@@ -229,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;
@@ -314,6 +596,19 @@ interface ConversationHeaderClassNames {
     desktopActions: string;
     mobileMenu: string;
 }
+/**
+ * Utilitário extra que o host pendura no cabeçalho — ícone no desktop, item de menu no celular,
+ * como os nativos. Entra por aqui, e não por um slot de ReactNode, porque é isso que preserva o
+ * comportamento responsivo: um nó solto viraria um quarto ícone em 375px, sem área de toque.
+ */
+interface ConversationHeaderUtility {
+    key: string;
+    /** Ícone da biblioteca (lucide), no tamanho dos utilitários nativos: `<Play size={16} />`. */
+    icon: ReactNode;
+    label: string;
+    run: () => void;
+    active?: boolean;
+}
 interface ConversationHeaderProps {
     conversation: ConversationSummary;
     busy?: boolean;
@@ -323,29 +618,46 @@ interface ConversationHeaderProps {
     onDownload?: () => void;
     onOpenDocuments?: () => void;
     documentsOpen?: boolean;
+    /** Ações do produto que não existem no contrato do pacote (ex.: ferramentas de dev). */
+    extraUtilities?: readonly ConversationHeaderUtility[];
     onBack?: () => void;
     labels?: Partial<ConversationHeaderLabels>;
     className?: string;
     classNames?: Partial<ConversationHeaderClassNames>;
 }
-declare function ConversationHeader({ conversation, busy, onTakeover, onReturnToBot, onFinish, onDownload, onOpenDocuments, documentsOpen, onBack, labels: labelsOverride, className, classNames, }: ConversationHeaderProps): react.JSX.Element;
+declare function ConversationHeader({ conversation, busy, onTakeover, onReturnToBot, onFinish, onDownload, onOpenDocuments, documentsOpen, extraUtilities, onBack, labels: labelsOverride, className, classNames, }: ConversationHeaderProps): react.JSX.Element;
 
 /**
  * "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 {
@@ -356,11 +668,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;
@@ -380,6 +704,217 @@ declare function WindowExpiredNotice({ onSendTemplate, disabled, labels: labelsO
  */
 declare function isWindowBlocking(window: ConversationWindow): boolean;
 
+/**
+ * Biblioteca de arquivos de TODAS as conversas — a tela de Documentos do painel, fora do
+ * atendimento.
+ *
+ * Distinta do `ConversationDocumentsPanel`: aquele parte de uma conversa aberta e vive dentro dela;
+ * esta varre a empresa e por isso mostra de qual conversa cada arquivo veio, com o número
+ * clicável. Sem essa referência, uma lista global de anexos não responde nenhuma pergunta.
+ */
+interface DocumentsLibraryLabels {
+    title: string;
+    searchPlaceholder: string;
+    empty: string;
+    noResults: string;
+    loading: string;
+    failure: string;
+    view: string;
+    download: string;
+    openConversation: string;
+    sourceFilterAll: string;
+    sourceFilterCustomer: string;
+    sourceFilterTeam: string;
+    sortMostRecent: string;
+    sortOldest: string;
+    clearFilters: string;
+    upload: string;
+    uploadError: string;
+    total: (count: number) => string;
+    page: (current: number, last: number) => string;
+}
+declare const DEFAULT_DOCUMENTS_LIBRARY_LABELS: DocumentsLibraryLabels;
+interface DocumentsLibraryClassNames {
+    root: string;
+    title: string;
+    filters: string;
+    search: string;
+    sourceSelect: string;
+    sortButton: string;
+    clearButton: string;
+    status: string;
+    list: string;
+    item: string;
+    conversationLink: string;
+    filename: string;
+    meta: string;
+    pagination: string;
+}
+interface DocumentsLibraryProps {
+    /** Itens por página. O total vem do servidor. */
+    perPage?: number;
+    /** Abrir a conversa de origem. Ausente, o número aparece como texto e não como link. */
+    onOpenConversation?: (conversationId: string) => void;
+    labels?: Partial<DocumentsLibraryLabels>;
+    className?: string;
+    classNames?: Partial<DocumentsLibraryClassNames>;
+}
+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 é
@@ -388,29 +923,76 @@ declare function isWindowBlocking(window: ConversationWindow): boolean;
  * Usa `useConversationDocuments`, então funciona com qualquer `ConversationsApi`. Host sem
  * biblioteca de documentos cai no estado vazio, sem quebrar.
  */
+/** Origens que o filtro oferece. `all` não é origem — é a ausência de filtro. */
+declare const DOCUMENT_SOURCE_FILTER: {
+    readonly ALL: "all";
+    readonly CUSTOMER: "customer";
+    readonly TEAM: "team";
+};
+type DocumentSourceFilter = (typeof DOCUMENT_SOURCE_FILTER)[keyof typeof DOCUMENT_SOURCE_FILTER];
 interface ConversationDocumentsPanelLabels {
     toggle: string;
     title: string;
     searchPlaceholder: string;
     empty: string;
+    /** Distinto de `empty`: sem resultado POR CAUSA do filtro, e não conversa sem anexo nenhum. */
+    noResults: string;
     loading: string;
     failure: string;
     download: string;
+    view: string;
+    sourceFilterAll: string;
+    sourceFilterCustomer: string;
+    sourceFilterTeam: string;
+    sortMostRecent: string;
+    sortOldest: string;
+    clearFilters: string;
+    selectAll: string;
+    downloadSelected: (count: number) => string;
+    archiveFailed: string;
+    total: (count: number) => string;
+    page: (current: number, last: number) => string;
 }
 declare const DEFAULT_CONVERSATION_DOCUMENTS_LABELS: ConversationDocumentsPanelLabels;
+/**
+ * Partes estilizáveis do painel, no mesmo contrato do `ConversationHeader`: `cn` funde por cima da
+ * base e conflito de utilitário (padding, tamanho de fonte, borda) fica com o valor do produto.
+ *
+ * `status` cobre carregando/erro/vazio de uma vez — são a mesma linha de texto auxiliar, e slots
+ * separados só multiplicariam chave para quem quer mudar a cor de aviso.
+ */
 interface ConversationDocumentsPanelClassNames {
     root: string;
     body: string;
+    title: string;
+    filters: string;
+    search: string;
+    sourceSelect: string;
+    sortButton: string;
+    clearButton: string;
+    status: string;
+    list: string;
+    item: string;
+    sourceBadge: string;
+    filename: string;
+    meta: string;
+    viewButton: string;
+    downloadButton: string;
+    pagination: string;
+    selectionBar: string;
+    checkbox: string;
 }
 interface ConversationDocumentsPanelProps {
     conversationId: string;
     /** Controlado de fora porque o gatilho vive no cabeçalho, junto das outras ações da conversa. */
     open: boolean;
+    /** Itens por página. O total vem do servidor; sem paginação no host, a barra não aparece. */
+    perPage?: number;
     labels?: Partial<ConversationDocumentsPanelLabels>;
     className?: string;
     classNames?: Partial<ConversationDocumentsPanelClassNames>;
 }
-declare function ConversationDocumentsPanel({ conversationId, open, labels: labelsOverride, className, classNames, }: ConversationDocumentsPanelProps): react.JSX.Element | null;
+declare function ConversationDocumentsPanel({ conversationId, open, perPage, labels: labelsOverride, className, classNames, }: ConversationDocumentsPanelProps): react.JSX.Element | null;
 
 /**
  * Serialização do transcript para download. Fica no pacote porque o formato de um histórico de
@@ -451,6 +1033,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.
  *
@@ -461,11 +1086,35 @@ declare function useDarkMode(): {
 declare const NARROW_MAX_WIDTH_PX = 1023;
 declare function useIsNarrow(): boolean;
 
+interface UseWaitingNotificationsLabels {
+    /** Título da notificação do sistema. Recebe a conversa para o host escolher nome × número. */
+    title: (conversation: ConversationSummary) => string;
+    body: (conversation: ConversationSummary) => string;
+}
+interface UseWaitingNotificationsParams {
+    /**
+     * Repassado cru ao `fetchConversations`. É o que permite filtrar não lidas **no servidor** em
+     * vez de baixar a lista inteira e contar no cliente: um painel com milhares de conversas não
+     * pode paginar 50 por vez atrás de quem tem `unread > 0`.
+     */
+    readonly params?: ListConversationsParams;
+    readonly intervalMs?: number;
+    /** Desliga o polling sem desmontar quem chama — útil com a aba em segundo plano. */
+    readonly enabled?: boolean;
+    readonly icon?: string;
+    readonly labels?: Partial<UseWaitingNotificationsLabels>;
+}
 interface UseWaitingNotificationsResult {
     unreadCount: number;
     conversations: ConversationSummary[];
+    /**
+     * Releitura sob demanda. Existe porque o polling é o piso, não o mecanismo: quem já recebe SSE
+     * ou acabou de marcar tudo como lido sabe da mudança antes do próximo tick, e esperar 10s para
+     * o contador acompanhar faz a interface parecer travada.
+     */
+    refresh: () => Promise<void>;
 }
-declare function useWaitingNotifications(): UseWaitingNotificationsResult;
+declare function useWaitingNotifications(params?: UseWaitingNotificationsParams): UseWaitingNotificationsResult;
 
 interface ConversationsContextValue {
     api: ConversationsApi;
@@ -547,6 +1196,7 @@ interface WhatsAppCreateTemplateFormLabels {
     sectionDescription: string;
     nameLabel: string;
     nameHint: string;
+    namePlaceholder: string;
     categoryLabel: string;
     languageLabel: string;
     headerLabel: string;
@@ -612,6 +1262,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";
@@ -642,10 +1333,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;
@@ -671,6 +1373,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;
@@ -684,7 +1468,7 @@ interface UseConversationMessagesResult {
         caption?: string;
     }) => Promise<MessagePayload>;
     sendTemplate: (data: {
-        templateName: string;
+        templateName?: string;
         languageCode?: string;
         bodyParams?: string[];
     }) => Promise<void>;
@@ -695,14 +1479,28 @@ declare function useConversationMessages(conversationId: string, params?: {
     before?: string;
 }): UseConversationMessagesResult;
 
-interface UseConversationListParams {
-    page?: number;
-    limit?: number;
-    waitingHuman?: boolean;
-    search?: string;
-}
+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[];
+    /** Total no servidor. Cai para o tamanho da página quando a API devolve só o array. */
+    total: number;
     loading: boolean;
     error: Error | undefined;
     refetch: () => Promise<void>;
@@ -717,12 +1515,11 @@ interface UseConversationContextResult {
 }
 declare function useConversationContext(conversationId: string): UseConversationContextResult;
 
-interface UseConversationDocumentsParams {
-    search?: string;
-    page?: number;
-}
+type UseConversationDocumentsParams = ListDocumentsParams;
 interface UseConversationDocumentsResult {
     documents: ConversationDocument[];
+    /** Total no servidor. Cai para o tamanho da página quando a API devolve só o array. */
+    total: number;
     loading: boolean;
     error: Error | undefined;
     refetch: () => Promise<void>;
@@ -733,6 +1530,27 @@ type ConversationRealtimeHandler = (event: MessageEvent) => void;
 declare function useConversationRealtime(conversationId: string | undefined, onEvent: ConversationRealtimeHandler): void;
 declare function useGlobalRealtime(onEvent: ConversationRealtimeHandler): void;
 
+interface UseConversationActionsResult {
+    /** `undefined` quando a API do host não implementa a operação — a UI esconde a afordância. */
+    takeover: (() => Promise<void>) | undefined;
+    release: (() => Promise<void>) | undefined;
+    finalize: (() => Promise<void>) | undefined;
+}
+/**
+ * Ações de atendimento de UMA conversa, já ligadas ao id.
+ *
+ * Separado de `useConversationMessages` porque assumir e devolver conversa também acontece a
+ * partir da lista, onde nenhuma thread está aberta — embutir nas mensagens obrigaria a carregar
+ * a thread inteira só para desenhar um botão na linha.
+ */
+declare function useConversationActions(conversationId: string): UseConversationActionsResult;
+interface UseInboxActionsResult {
+    markAllRead: (() => Promise<void>) | undefined;
+    listTemplates: (() => Promise<ConversationTemplate[]>) | undefined;
+}
+/** Ações que valem para a caixa inteira, sem conversa selecionada. */
+declare function useInboxActions(): UseInboxActionsResult;
+
 declare function parseWhatsAppFormatting(text: string): ReactNode[];
 declare function waToHTML(text: string): string;
 declare function htmlToWA(html: string): string;
@@ -742,6 +1560,8 @@ declare function formatPhone(number: string): string;
 declare function phoneInitials(number: string): string;
 
 declare function formatTimestamp(timestamp: string): string;
+declare function formatDateTime(iso: string): string;
+declare function isSameDay(a: Date, b: Date): boolean;
 declare function formatFileSize(bytes: number): string;
 
 interface AsyncResourceState<T> {
@@ -751,4 +1571,313 @@ interface AsyncResourceState<T> {
     refetch: () => Promise<void>;
 }
 
-export { type AsyncResourceState, AudioPlayer, type AudioPlayerProps, Avatar, 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, ConversationListItem, type ConversationListItemProps, type ConversationLocales, ConversationLocalesProvider, type ConversationLocalesProviderProps, type ConversationRealtimeHandler, ConversationRow, type ConversationRowClassNames, type ConversationRowProps, ConversationSummary, ConversationWallpaper, type ConversationWallpaperProps, type ConversationWindow, ConversationsApi, ConversationsFeatures, ConversationsProvider, DEFAULT_CONVERSATION_CONTEXT_LABELS, DEFAULT_CONVERSATION_DOCUMENTS_LABELS, DEFAULT_CONVERSATION_HEADER_LABELS, DEFAULT_TEMPLATES_SETTINGS_LABELS, DEFAULT_WINDOW_EXPIRED_LABELS, DateDivider, type DateDividerClassNames, type DateDividerProps, EmojiPicker, type EmojiPickerProps, FileIcon, type FileIconProps, Lightbox, type LightboxProps, MediaRenderer, type MediaRendererProps, MessageBubble, type MessageBubbleProps, MessageComposer, type MessageComposerClassNames, type MessageComposerProps, MessagePayload, MessageTail, MessageText, type MessageTextProps, MessageTimestamp, NARROW_MAX_WIDTH_PX, type ResolveMediaUrl, SSEProvider, SimpleEmojiPicker, type SimpleEmojiPickerProps, StatusTicks, type StatusTicksProps, TEMPLATE_SETTINGS_TAB, type TemplateSettingsTab, ToastProvider, type TopicItem, TopicsForm, type TopicsFormLabels, type TopicsFormProps, type UseConversationContextResult, type UseConversationDocumentsParams, type UseConversationDocumentsResult, type UseConversationListParams, type UseConversationListResult, type UseConversationMessagesResult, WINDOW_FILTERS, WelcomeFarewellForm, type WelcomeFarewellFormLabels, type WelcomeFarewellFormProps, WhatsAppCreateTemplateForm, type WhatsAppCreateTemplateFormLabels, type WhatsAppCreateTemplateFormProps, type WhatsAppCreateTemplateResult, type WhatsAppCreateTemplateState, WhatsAppMessageEditor, 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, downloadTextFile, formatFileSize, formatPhone, formatStalledFor, formatTimestamp, htmlToWA, isWindowBlocking, parseWhatsAppFormatting, phoneInitials, toast, useConversationContext, useConversationDocuments, useConversationList, useConversationLocales, useConversationMessages, useConversationRealtime, useConversations, useDarkMode, useGlobalRealtime, useIsDarkTheme, useIsNarrow, useToast, useWaitingNotifications, waToHTML, waToHTMLInline, windowOf };
+/**
+ * Resolve a mídia de uma mensagem numa URL exibível, usando só o `ConversationsApi`.
+ *
+ * Mora no pacote, e não em cada host, porque a regra não tem nada de específico de produto: é a
+ * tradução de `uploadId`/`mediaId` pelos dois métodos que o próprio contrato já declara. Deixá-la no
+ * host significava que todo projeto que adotasse o SDK reescreveria as mesmas oito linhas — e, na
+ * prática, ninguém escrevia: o `MediaRenderer` só busca mídia pela porta `onResolveMediaUrl`, então
+ * onde nada era injetado foto, vídeo e áudio ficavam no placeholder para sempre.
+ */
+
+declare function createMediaUrlResolver(api: Pick<ConversationsApi, 'getDocumentUrl' | 'getMediaProxyUrl'>): ResolveMediaUrl;
+
+/**
+ * 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, RICH_COMPOSER_ACTION, 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, isSameDay, isWindowBlocking, parseWhatsAppFormatting, phoneInitials, 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 };