> ## Documentation Index
> Fetch the complete documentation index at: https://zapo.to/llms.txt
> Use this file to discover all available pages before exploring further.

# WaClient & coordinators

> Referência completa de métodos do WaClient e de cada coordinator: auth, message, presence, chat, group, newsletter, profile e mais.

Esta página lista **todos** os métodos públicos do `WaClient` e de seus coordinators, com descrições fundamentadas no código. Páginas dedicadas se aprofundam em [tipos de mensagem](/pt-br/reference/message-types), [mutations de chat](/pt-br/reference/chat-mutations) e a [API de baixo nível](/pt-br/reference/low-level).

<h2 id="waclient">
  WaClient
</h2>

```ts theme={null}
new WaClient(options: WaClientOptions, logger?: Logger)
```

Veja [Configuração](/pt-br/concepts/configuration) para todas as opções.

| Member                | Signature                                                    | Description                                                                                                                                                                                                       |
| --------------------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connect`             | `() => Promise<void>`                                        | Abre o socket e executa o handshake Noise; conduz o pareamento na primeira execução. Resolve quando conectado.                                                                                                    |
| `disconnect`          | `() => Promise<void>`                                        | Faz o flush das escritas write-behind pendentes e fecha o socket, mantendo as credenciais.                                                                                                                        |
| `logout`              | `(reason?: WaLogoutReason) => Promise<void>`                 | Desvincula este dispositivo companion no lado do servidor; depois limpa o estado armazenado conforme [`logoutStoreClear`](/pt-br/concepts/configuration#logout-store-clearing). Lança se não estiver autenticado. |
| `getState`            | `() => WaAuthState`                                          | Estado atual de auth/conexão.                                                                                                                                                                                     |
| `getCredentials`      | `() => WaAuthCredentials \| null`                            | Credenciais atuais, se pareado.                                                                                                                                                                                   |
| `getClockSkewMs`      | `() => number \| null`                                       | Desvio estimado do relógio do servidor (a partir do keep-alive), ou `null`.                                                                                                                                       |
| `ignoreKey`           | `(input: WaIgnoreKey \| WaIgnoreKeyPredicate) => () => void` | Descarta stanzas inbound que casam **antes** de qualquer handler rodar — descriptor ou predicate (veja [Ignorando stanzas inbound](#ignoring-inbound-stanzas)). Retorna uma função `unregister`.                  |
| `on` / `once` / `off` | `(event, listener) => this`                                  | Emissor de eventos tipado sobre o [`WaClientEventMap`](/pt-br/concepts/events).                                                                                                                                   |

<h3 id="ignoring-inbound-stanzas">
  Ignorando stanzas inbound
</h3>

`client.ignoreKey(input)` descarta stanzas `<message>`, `<receipt>`, `<notification>`, `<presence>`, `<chatstate>` e `<call>` que casam antes de qualquer handler — incluindo os caminhos de persistência e decifragem — ver. O coordinator ainda envia o ack apropriado para o servidor parar de re-entregar.

Aceita dois formatos:

<h4 id="declarative-descriptor--waignorekey">
  Descriptor declarativo — `WaIgnoreKey`
</h4>

```ts theme={null}
import type { WaIgnoreKey } from 'zapo-js'

// Descarta tudo de um peer
const off = client.ignoreKey({ remoteJid: spammerJid })

// Descarta só as mensagens daquele peer (mantém receipts / presence)
client.ignoreKey({ remoteJid: spammerJid, only: ['message'] })

// Descarta os echoes das suas próprias mensagens (multi-device fan-in)
client.ignoreKey({ fromMe: true, only: ['message'] })

off() // unregister
```

| Campo         | Tipo                                                                                           | Notas                                                                                                                                                                                                           |
| ------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remoteJid`   | `string \| readonly string[]`                                                                  | O JID do chat. Entradas do array fazem OR. Também casa contra os attrs alt `sender_pn` / `sender_lid` / `participant_pn` / `participant_lid` (e `sender_lid` em `<call>`), então uma forma do JID pega a outra. |
| `fromMe`      | `boolean`                                                                                      | Se a stanza foi enviada por esta conta.                                                                                                                                                                         |
| `id`          | `string`                                                                                       | Id da stanza.                                                                                                                                                                                                   |
| `participant` | `string`                                                                                       | O autor em grupos / broadcasts. Também casa contra as formas alt.                                                                                                                                               |
| `only`        | `readonly ('message' \| 'receipt' \| 'notification' \| 'presence' \| 'chatstate' \| 'call')[]` | Restringe a tags específicas. Default: todas as seis.                                                                                                                                                           |

Múltiplos campos de topo fazem **AND** entre si; o array de `remoteJid` faz **OR**. Pelo menos um de `remoteJid` / `fromMe` / `id` / `participant` é obrigatório — descriptors vazios e arrays vazios lançam erro.

<h4 id="predicate--waignorekeypredicate">
  Predicate — `WaIgnoreKeyPredicate`
</h4>

Pra qualquer coisa que o descriptor não consiga expressar (filtros por kind de chat, regras customizadas combinando vários campos), passe um predicate `(ctx: WaIgnoreKeyContext) => boolean`. Retorne `true` pra descartar. A lib já fez o parse do node em wire-format antes de chamar — sem precisar mexer em `BinaryNode`.

```ts theme={null}
import { isGroupJid, isStatusBroadcastJid, isNewsletterJid } from 'zapo-js'

// Descarta toda mensagem de grupo; mantém receipts/notifications de grupo
client.ignoreKey((m) => m.kind === 'message' && isGroupJid(m.remoteJid ?? ''))

// Descarta todos os status broadcasts
client.ignoreKey((m) => isStatusBroadcastJid(m.remoteJid ?? ''))

// Só 1:1 — descarta qualquer coisa de grupo, broadcast ou newsletter
client.ignoreKey((m) => {
  const j = m.remoteJid ?? ''
  return isGroupJid(j) || isStatusBroadcastJid(j) || isNewsletterJid(j)
})
```

O `WaIgnoreKeyContext` carrega os mesmos campos contra os quais o descriptor casa, já parseados:

| Campo         | Tipo                                                                              | Notas                                                                                                                                                                                                                                  |
| ------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `kind`        | `'message' \| 'receipt' \| 'notification' \| 'presence' \| 'chatstate' \| 'call'` | Tag da stanza.                                                                                                                                                                                                                         |
| `remoteJid`   | `string \| null`                                                                  | JID do chat sem device — JID do grupo para grupos, JID PN ou LID na forma **user** para 1:1 (o segmento `:device` é stripped para casar com `event.key.remoteJid`). Valores `from` sem user (ex.: `s.whatsapp.net`) ficam como vieram. |
| `fromMe`      | `boolean`                                                                         | Já resolvido contra o `meJid` da conta.                                                                                                                                                                                                |
| `id`          | `string \| undefined`                                                             | Id da stanza.                                                                                                                                                                                                                          |
| `participant` | `string \| null`                                                                  | O autor em grupos / broadcasts. Mesmo stripping de device do `remoteJid`; `null` para stanzas que não são de grupo.                                                                                                                    |

<Note>
  O predicate vê `from` / `participant` com o device stripped — mas **sem** resolução de alt-attr PN ↔ LID. O formato descriptor é quem cuida da parte de PN ↔ LID automaticamente; se você precisa de matching por JID com cobertura de forma alt *junto* de uma regra custom, prefira o `remoteJid` do descriptor com `only`.
</Note>

<Note>
  Os nodes de controle de stream e as tags `success` / `failure` críticas para a conexão passam pelos filtros para manter o fluxo de auth intacto.
</Note>

<h3 id="coordinator-getters">
  Coordinator getters
</h3>

| Getter          | Type                            | Section                                          |
| --------------- | ------------------------------- | ------------------------------------------------ |
| `auth`          | `WaAuthClient`                  | [auth](#auth)                                    |
| `message`       | `WaMessageCoordinator`          | [message](#message)                              |
| `presence`      | `WaPresenceCoordinator`         | [presence](#presence)                            |
| `chat`          | `WaAppStateMutationCoordinator` | [chat](#chat)                                    |
| `group`         | `WaGroupCoordinator`            | [group](#group)                                  |
| `status`        | `WaStatusCoordinator`           | [status](#status)                                |
| `broadcastList` | `WaBroadcastListCoordinator`    | [broadcastList](#broadcastlist)                  |
| `newsletter`    | `WaNewsletterCoordinator`       | [newsletter](#newsletter)                        |
| `privacy`       | `WaPrivacyCoordinator`          | [privacy](#privacy)                              |
| `profile`       | `WaProfileCoordinator`          | [profile](#profile)                              |
| `business`      | `WaBusinessCoordinator`         | [business](#business)                            |
| `bot`           | `WaBotCoordinator`              | [bot](#bot)                                      |
| `email`         | `WaEmailCoordinator`            | [email](#email)                                  |
| `mobile`        | `WaMobileCoordinator`           | [mobile](#mobile)                                |
| `lowlevel`      | `WaLowLevelCoordinator`         | [API de baixo nível](/pt-br/reference/low-level) |

***

<h2 id="auth">
  auth
</h2>

`client.auth` (`WaAuthClient`). O pareamento é majoritariamente orientado a eventos ([Autenticação](/pt-br/concepts/authentication)); estes são os pontos de entrada voltados ao usuário.

| Method                       | Signature                                                                    | Description                                                                                                                                                                                                               |
| ---------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `requestPairingCode`         | `(phoneNumber, shouldShowPushNotification?, customCode?) => Promise<string>` | Solicita um código de pareamento de 8 caracteres (fluxo link-code). O client já deve estar conectado — chame após o evento `auth_pairing_required`. `customCode` sugere um código; o servidor pode retornar um diferente. |
| `fetchPairingCountryCodeIso` | `() => Promise<string>`                                                      | O código ISO de país que o servidor resolveu para a conta.                                                                                                                                                                |
| `getState`                   | `(connected?) => { connected, registered, hasQr, hasPairingCode }`           | Flags de prontidão de auth.                                                                                                                                                                                               |
| `getCurrentCredentials`      | `() => WaAuthCredentials \| null`                                            | Credenciais carregadas, ou `null`.                                                                                                                                                                                        |

***

<h2 id="message">
  message
</h2>

`WaMessageCoordinator` — veja [Envio](/pt-br/guides/sending-messages) & [Recebimento](/pt-br/guides/receiving-messages).

| Method                     | Signature                                                                                                | Description                                                                                                                                                                                                                                      |
| -------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `send`                     | `(to, content: WaSendMessageContent, options?: WaSendMessageOptions) => Promise<WaMessagePublishResult>` | Envia qualquer [tipo de conteúdo](/pt-br/reference/message-types); lida com o fanout de dispositivos e retries por envio. Retorna o id da stanza + metadados de ack.                                                                             |
| `sendReceipt`              | `(event\|events, options?)` / `(jid, ids, options?) => Promise<void>`                                    | Envia um recibo de entrega/leitura/reprodução/inatividade. A entrega recebe ack automático ao descriptografar; use isto para leitura/reprodução manual.                                                                                          |
| `requestHistorySync`       | `(input: WaRequestHistorySyncInput) => Promise<{ messageId }>`                                           | Pede ao servidor para baixar mensagens mais antigas de um chat. Resolve assim que despachado — o backlog chega depois como `history_sync_chunk`. Veja [Solicitando histórico antigo](/pt-br/guides/receiving-messages#requesting-older-history). |
| `download`                 | `(source, options?) => Promise<Readable>`                                                                | Faz streaming de mídia descriptografada (MAC + SHA-256 verificados conforme consumida). Cancele via `options.signal`.                                                                                                                            |
| `downloadToFile`           | `(source, filePath, options?) => Promise<void>`                                                          | Faz streaming de mídia descriptografada para um arquivo.                                                                                                                                                                                         |
| `downloadBytes`            | `(source, options?) => Promise<Uint8Array>`                                                              | Bufferiza mídia descriptografada na memória — apenas mídia pequena; limite com `options.maxBytes`.                                                                                                                                               |
| `tryDecryptAddon`          | `(event) => Promise<void>`                                                                               | Descriptografa um addon (voto em enquete, reação, …) e emite `message_addon`. Chamado automaticamente por padrão; opt-out com `addons: { autoDecrypt: false }` para chamar você mesmo.                                                           |
| `syncSignalSession`        | `(jid, reasonIdentity?) => Promise<void>`                                                                | Força a atualização da(s) sessão(ões) Signal de um JID; `reasonIdentity` também reemite o token de contato confiável.                                                                                                                            |
| `getReachoutTimelock`      | `() => Promise<WaReachoutTimelock>`                                                                      | Timelock do lado do servidor que limita o cold outreach a não-contatos.                                                                                                                                                                          |
| `getNewChatMessageCapping` | `(type?) => Promise<WaMessageCappingInfo>`                                                               | Cota de mensagens por ciclo aplicada a threads de chats novos (cota, usado, ciclo, status).                                                                                                                                                      |

`source` é um `WaIncomingMessageEvent` ou um `Proto.IMessage` bruto.

***

<h2 id="presence">
  presence
</h2>

`WaPresenceCoordinator` — veja [Presença & status](/pt-br/guides/presence-status).

| Method          | Signature                                                | Description                                                                                                  |
| --------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `send`          | `(type?: 'available' \| 'unavailable') => Promise<void>` | Faz o broadcast da sua presença online/offline.                                                              |
| `sendChatstate` | `(jid, options) => Promise<void>`                        | Envia uma dica de digitando/gravando/pausado para um chat.                                                   |
| `subscribe`     | `(jid, options?) => Promise<void>`                       | Inscreve-se na presença/chat-state de um contato. Por jid e por conexão — **reinscreva-se após reconectar**. |

***

<h2 id="chat">
  chat
</h2>

`WaAppStateMutationCoordinator` — referência completa (incluindo o `set`/`remove` genérico e todos os schemas) em [Mutations de chat](/pt-br/reference/chat-mutations).

| Method                                                          | Signature                                                |
| --------------------------------------------------------------- | -------------------------------------------------------- |
| `setChatMute`                                                   | `(chatJid, muted, muteEndTimestampMs?) => Promise<void>` |
| `setChatPin` / `setChatArchive` / `setChatRead` / `setChatLock` | `(chatJid, boolean) => Promise<void>`                    |
| `setMessageStar`                                                | `(message, starred) => Promise<void>`                    |
| `clearChat` / `deleteChat`                                      | `(chatJid, options?) => Promise<void>`                   |
| `deleteMessageForMe`                                            | `(message, options?) => Promise<void>`                   |
| `setStatusPrivacy` / `setUserStatusMute`                        | `(input) / (jid, muted) => Promise<void>`                |
| `setBroadcastList` / `removeBroadcastList`                      | `(input) / (id) => Promise<void>`                        |
| `set` / `remove`                                                | `(input) => Promise<void>`                               |
| `sync` / `flushMutations`                                       | `(options?) / () => Promise<…>`                          |
| `getBlockedCollections` / `emitEventsFromSyncResult`            | `(syncResult) => …`                                      |

<Note>
  Pin e arquivamento são mutuamente exclusivos (fixar limpa o arquivamento e vice-versa); travar limpa ambos. `clearChat`/`deleteChat`/`deleteMessageForMe` são **somente locais** (seus dispositivos) — use um [revoke](/pt-br/guides/interactive-messages#revoking-delete-for-everyone) para apagar para todos. Um timer de silenciamento não desativa o mudo automaticamente no lado do client.
</Note>

***

<h2 id="group">
  group
</h2>

`WaGroupCoordinator` — veja [Grupos & comunidades](/pt-br/guides/groups). Operações sobre participantes retornam um [`WaParticipantActionResult`](/pt-br/guides/groups#managing-participants) por jid — o IQ tem sucesso como um todo mesmo quando alguns falham, então verifique o `status` / `code` de cada resultado.

| Method                                                   | Signature                                                                              | Description                                                                                                                                                                 |
| -------------------------------------------------------- | -------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `queryGroupMetadata`                                     | `(groupJid) => Promise<WaGroupMetadata>`                                               | Metadados completos do grupo.                                                                                                                                               |
| `queryAllGroups`                                         | `() => Promise<readonly WaGroupMetadata[]>`                                            | Todos os grupos dos quais a conta participa.                                                                                                                                |
| `queryGroupInviteInfo`                                   | `(code) => Promise<WaGroupInviteInfo>`                                                 | Preview de um código de convite (assunto, tamanho, ephemeral, descrição, amostra reduzida de participantes).                                                                |
| `createGroup`                                            | `(subject, participants, options?) => Promise<WaGroupMetadata>`                        | Cria um grupo (você é adicionado automaticamente como admin; não inclua seu próprio JID). Retorna o metadata do novo grupo.                                                 |
| `setSubject`                                             | `(groupJid, subject) => Promise<void>`                                                 | Renomeia.                                                                                                                                                                   |
| `setDescription`                                         | `(groupJid, description\|null, prevDescId?) => Promise<void>`                          | Define/limpa a descrição.                                                                                                                                                   |
| `setSetting`                                             | `(groupJid, setting, enabled) => Promise<void>`                                        | Alterna uma flag booleana do grupo (`announcement`, `restrict`, `ephemeral`, `group_history`, `allow_admin_reports`, `no_frequently_forwarded`, flags de comunidade).       |
| `setMemberAddMode`                                       | `(groupJid, 'admin_add' \| 'all_member_add') => Promise<void>`                         | Restringe quem pode adicionar membros (só admins ou qualquer um). Op. de admin.                                                                                             |
| `setMemberLinkMode`                                      | `(groupJid, 'admin_link' \| 'all_member_link') => Promise<void>`                       | Restringe quem pode compartilhar o link de convite. Op. de admin.                                                                                                           |
| `setMemberShareGroupHistoryMode`                         | `(groupJid, 'admin_share' \| 'all_member_share') => Promise<void>`                     | Esconde ou expõe o histórico anterior para novos membros. Op. de admin.                                                                                                     |
| `setEphemeralDuration`                                   | `(groupJid, expirationSeconds, trigger?) => Promise<void>`                             | Liga as mensagens temporárias com uma duração específica (`86400` = 24h, `604800` = 7d, `7776000` = 90d). Use `setSetting('ephemeral', false)` para desligar. Op. de admin. |
| `addParticipants` / `removeParticipants`                 | `(groupJid, jids) => Promise<readonly WaParticipantActionResult[]>`                    | Adiciona / remove membros. Um resultado por jid; verifique `status` / `code` para falhas parciais.                                                                          |
| `promoteParticipants` / `demoteParticipants`             | `(groupJid, jids) => Promise<readonly WaParticipantActionResult[]>`                    | Concede / revoga admin. Mesmo formato por jid.                                                                                                                              |
| `leaveGroup`                                             | `(groupJids) => Promise<void>`                                                         | Sai de um ou mais grupos (em lote).                                                                                                                                         |
| `queryInviteCode`                                        | `(groupJid) => Promise<string>`                                                        | Busca o código de convite atual (o segmento de caminho de `chat.whatsapp.com/<code>`) **sem** rotacioná-lo. Operação de admin — não-admins recebem `403 not-authorized`.    |
| `revokeInvite`                                           | `(groupJid) => Promise<WaRevokeInviteResult>`                                          | Rotaciona o código de convite — todo link `chat.whatsapp.com/<code>` antigo para de funcionar. Retorna o novo `code` mais `affectedParticipants`.                           |
| `joinGroupViaInvite`                                     | `(code) => Promise<WaGroupMetadata>`                                                   | Entra via código. Lança se expirado/revogado/lotado/já for membro. Retorna o metadata do grupo.                                                                             |
| `createCommunity`                                        | `(subject, options?) => Promise<WaGroupMetadata>`                                      | Cria uma comunidade (requer solicitação a menos que `membershipApprovalMode: 'open'`).                                                                                      |
| `deactivateCommunity`                                    | `(communityJid) => Promise<void>`                                                      | Exclui uma comunidade.                                                                                                                                                      |
| `linkSubGroups` / `unlinkSubGroups`                      | `(communityJid, jids, options?) => Promise<…>`                                         | Vincula / desvincula sub-grupos (`removeOrphanedMembers` remove membros órfãos).                                                                                            |
| `queryLinkedGroupsParticipants`                          | `(communityJid) => Promise<readonly WaGroupParticipant[]>`                             | Participantes mesclados de uma comunidade.                                                                                                                                  |
| `fetchSubGroups`                                         | `(communityJid) => Promise<WaCommunitySubGroupsResult>`                                | Lista os sub-grupos (MEX).                                                                                                                                                  |
| `joinLinkedGroup`                                        | `(communityJid, subGroupJid, options?) => Promise<void>`                               | Entra em um sub-grupo vinculado. Chame `queryGroupMetadata` depois para obter o metadata completo.                                                                          |
| `queryMembershipApprovalRequests`                        | `(groupJid) => Promise<readonly WaMembershipRequest[]>`                                | Solicitações de entrada pendentes.                                                                                                                                          |
| `approveMembershipRequests` / `rejectMembershipRequests` | `(groupJid, jids) => Promise<void>`                                                    | Aprova / rejeita solicitações.                                                                                                                                              |
| `cancelMembershipRequests`                               | `(groupJid, jids) => Promise<void>`                                                    | Cancela suas próprias solicitações pendentes.                                                                                                                               |
| `isInternalGroup`                                        | `(groupJid) => Promise<boolean>`                                                       | `true` para grupos internos do WhatsApp (MEX).                                                                                                                              |
| `transferCommunityOwnership`                             | `(communityJid, newOwnerJid) => Promise<void>`                                         | Transfere a propriedade da comunidade (MEX).                                                                                                                                |
| `fetchSubgroupSuggestions`                               | `(communityJid, hintSubgroupJid) => Promise<readonly WaCommunitySubGroupSuggestion[]>` | Sub-grupos sugeridos (MEX).                                                                                                                                                 |
| `submitGroupSuspensionAppeal`                            | `(groupJid, options?) => Promise<WaGroupSuspensionAppealResult>`                       | Recorre de uma suspensão (MEX).                                                                                                                                             |

<Note>Métodos marcados com (MEX) exigem um transport [MEX](/pt-br/reference/glossary#mex) ativo e lançam quando ele está indisponível.</Note>

***

<h2 id="newsletter">
  newsletter
</h2>

`WaNewsletterCoordinator` — veja [Newsletters](/pt-br/guides/newsletters). Composto de operações de discovery, admin e messaging.

<h3 id="discovery">
  Discovery
</h3>

| Method                            | Signature                                                               | Description                              |
| --------------------------------- | ----------------------------------------------------------------------- | ---------------------------------------- |
| `fetch` / `fetchByInvite`         | `(jid\|code, options?) => Promise<WaNewsletterMetadata>`                | Metadados por JID ou código de convite.  |
| `fetchDehydrated`                 | `(keyOrInvite, options?) => Promise<WaNewsletterDehydratedMetadata>`    | Metadados leves (sem imagem/seguidores). |
| `listSubscribed`                  | `(options?) => Promise<readonly WaNewsletterMetadata[]>`                | Canais que você segue.                   |
| `searchDirectory`                 | `(options?) => Promise<WaNewsletterDirectoryResults>`                   | Pesquisa no diretório público.           |
| `fetchRecommended`                | `(options?) => Promise<readonly WaNewsletterMetadata[]>`                | Canais recomendados.                     |
| `fetchSimilar`                    | `(jid, options?) => Promise<readonly WaNewsletterMetadata[]>`           | Canais semelhantes a um.                 |
| `fetchDirectoryList`              | `(options) => Promise<WaNewsletterDirectoryResults>`                    | Diretório paginado por país/categoria.   |
| `fetchDirectoryCategoriesPreview` | `(options) => Promise<readonly WaNewsletterDirectoryCategoryPreview[]>` | Prévias de carrossel por categoria.      |
| `fetchIsDomainPreviewable`        | `(domains) => Promise<ReadonlyMap<string, boolean>>`                    | Quais domínios suportam prévias de link. |

<h3 id="admin">
  Admin
</h3>

| Method                        | Signature                                                                   | Description                                                                                              |
| ----------------------------- | --------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| `create`                      | `(input) => Promise<WaNewsletterMetadata>`                                  | Cria um canal (aceita automaticamente os TOS de criação; `picture` é enviada inline — mantenha pequena). |
| `update`                      | `(jid, input) => Promise<WaNewsletterMetadata>`                             | Edita nome/descrição/imagem.                                                                             |
| `delete`                      | `(jid) => Promise<void>`                                                    | Exclusão **irreversível** — seguidores desvinculados, histórico descartado, JID queimado.                |
| `fetchAdminInfo`              | `(jid) => Promise<WaNewsletterAdminInfo>`                                   | Visão de metadados restrita a admins.                                                                    |
| `fetchAdminCapabilities`      | `(jid) => Promise<ReadonlySet<WaNewsletterCapability>>`                     | Capabilities concedidas à conta.                                                                         |
| `fetchFollowers`              | `(jid, options?) => Promise<WaNewsletterFollowersPage>`                     | Lista paginada de seguidores.                                                                            |
| `fetchInsights`               | `(jid, metrics) => Promise<… \| null>`                                      | Analytics de admin.                                                                                      |
| `fetchReports`                | `() => Promise<… \| null>`                                                  | Denúncias de moderação contra canais que você possui.                                                    |
| `fetchPendingInvites`         | `(jid) => Promise<readonly string[]>`                                       | JIDs de convites de admin pendentes.                                                                     |
| `fetchEnforcements`           | `(jid) => Promise<… \| null>`                                               | Estado de aplicação de moderação.                                                                        |
| `fetchPollVoters`             | `(input) => Promise<ReadonlyMap<string, readonly WaNewsletterPollVoter[]>>` | Votantes da enquete agrupados por opção.                                                                 |
| `fetchMessageReactionSenders` | `(input) => Promise<readonly WaNewsletterReactionSenders[]>`                | Remetentes de reações agrupados por emoji.                                                               |
| `createAdminInvite`           | `(input) => Promise<WaNewsletterAdminInviteResult>`                         | Convida um usuário como admin.                                                                           |
| `acceptAdminInvite`           | `(jid) => Promise<void>`                                                    | Aceita um convite de admin pendente (aceita os TOS automaticamente).                                     |
| `revokeAdminInvite`           | `(input) => Promise<void>`                                                  | Revoga um convite de admin enviado.                                                                      |
| `changeOwner`                 | `(input) => Promise<void>`                                                  | Transfere a propriedade para um admin convidado.                                                         |
| `demoteAdmin`                 | `(input) => Promise<void>`                                                  | Rebaixa um admin a seguidor.                                                                             |
| `queryTosState` / `acceptTos` | `(noticeIds) => Promise<…>`                                                 | Consulta / aceita avisos de TOS.                                                                         |
| `logExposures`                | `(exposures) => Promise<void>`                                              | Reporta exposições de capability (telemetria).                                                           |

<h3 id="messaging">
  Messaging
</h3>

| Method                                              | Signature                                                            | Description                                                              |
| --------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| `send`                                              | `(jid, content, options?) => Promise<WaNewsletterSendResult>`        | Publica uma mensagem (qualquer tipo de conteúdo).                        |
| `editMessage`                                       | `(jid, parentMessageId, content) => Promise<WaNewsletterSendResult>` | Edita uma mensagem publicada.                                            |
| `react` / `revoke` / `votePoll` / `sendViewReceipt` | `(input) => Promise<{ stanzaId }>`                                   | Reage / revoga / vota / recibo de visualização.                          |
| `fetchMessages` / `fetchMessageUpdates`             | `(input) => Promise<BinaryNode>`                                     | Pagina mensagens / busca edições-reações-votos em um intervalo.          |
| `subscribeLiveUpdates`                              | `(jid) => Promise<{ durationSeconds }>`                              | Inscreve-se em atualizações ao vivo (**reinscreva-se após reconectar**). |
| `follow` / `unfollow`                               | `(jid) => Promise<void>`                                             | Segue / deixa de seguir.                                                 |
| `mute`                                              | `(input) => Promise<void>`                                           | Silencia / dessilencia.                                                  |

***

<h2 id="privacy">
  privacy
</h2>

`WaPrivacyCoordinator` — veja [Privacidade](/pt-br/guides/profile-privacy#privacy).

| Method                      | Signature                                              | Description                                                                                                                                          |
| --------------------------- | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `getPrivacySettings`        | `() => Promise<WaPrivacySettings>`                     | Valor atual de cada categoria de privacidade.                                                                                                        |
| `setPrivacySetting`         | `(setting, value) => Promise<void>`                    | Atualiza uma categoria. Um valor no estilo `contact_blacklist` apenas alterna o modo — popule a lista separadamente via disallowed-list + app-state. |
| `getDisallowedList`         | `(category) => Promise<WaPrivacyDisallowedListResult>` | JIDs excluídos por categoria.                                                                                                                        |
| `getBlocklist`              | `() => Promise<WaBlocklistResult>`                     | Lista de bloqueio de toda a conta.                                                                                                                   |
| `blockUser` / `unblockUser` | `(jid) => Promise<void>`                               | Bloqueia / desbloqueia. Um bloqueio impede o peer de mandar mensagem/ligar para você e oculta seu visto-por-último/online/foto/status dele.          |

***

<h2 id="profile">
  profile
</h2>

`WaProfileCoordinator` — veja [Perfil](/pt-br/guides/profile-privacy#profile).

| Method                      | Signature                                                                            | Description                                                                                                                                                                                                                                            |
| --------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `getProfilePicture`         | `(jid, type?: 'preview' \| 'image', existingId?) => Promise<WaProfilePictureResult>` | Envelope da imagem (`{ url?, directPath?, id?, type? }`). `type` default é `'preview'` (variante compacta); `'image'` retorna o original em alta resolução. Passe o `existingId` cacheado para o servidor fazer short-circuit quando a foto não mudou. |
| `setProfilePicture`         | `(imageBytes, targetJid?) => Promise<string \| null>`                                | Define a imagem sua/de um alvo. `imageBytes` é enviado **como está** — pré-codifique um JPEG quadrado. Retorna o id da imagem.                                                                                                                         |
| `deleteProfilePicture`      | `(targetJid?) => Promise<void>`                                                      | Remove a imagem (operação de admin para grupos).                                                                                                                                                                                                       |
| `getStatus` / `setStatus`   | `(jid) / (text) => Promise<…>`                                                       | Obtém/define o "Sobre" legado.                                                                                                                                                                                                                         |
| `setPushName`               | `(name) => Promise<void>`                                                            | Atualiza o nome de exibição broadcast aos contatos. Aplicado às credenciais locais imediatamente e roteado por uma mutação de app-state; os contatos veem na sua próxima mensagem enviada. String vazia restaura o padrão do dispositivo.              |
| `getProfiles`               | `(jids) => Promise<readonly WaProfileInfo[]>`                                        | Id de imagem + status em lote.                                                                                                                                                                                                                         |
| `getDisappearingMode`       | `(jids) => Promise<readonly WaDisappearingModeResult[]>`                             | Configuração de modo temporário em lote.                                                                                                                                                                                                               |
| `setDisappearingMode`       | `(durationSeconds) => Promise<void>`                                                 | Define a duração padrão de modo temporário aplicada a **novos** chats 1:1 (`0`/`86400`/`604800`/`7776000`). Chats existentes mantêm a configuração.                                                                                                    |
| `getTextStatuses`           | `(jids) => Promise<readonly WaTextStatusResult[]>`                                   | Status de texto moderno em lote (emoji + texto).                                                                                                                                                                                                       |
| `setTextStatus`             | `(input) => Promise<void>`                                                           | Define seu status de texto moderno; `text: null`/`''` o limpa.                                                                                                                                                                                         |
| `getUsernames`              | `(jids) => Promise<readonly WaUsernameResult[]>`                                     | Consulta de username em lote.                                                                                                                                                                                                                          |
| `getOwnUsername`            | `() => Promise<WaOwnUsernameResult>`                                                 | Seu registro de username (valor, estado, pin de recuperação).                                                                                                                                                                                          |
| `setUsername`               | `(input) => Promise<boolean>`                                                        | Reserva um username. Retorna `true` apenas em `SUCCESS`; caso contrário `false` (em uso/inválido/rate-limited) sem lançar.                                                                                                                             |
| `deleteUsername`            | `() => Promise<boolean>`                                                             | Exclui seu username.                                                                                                                                                                                                                                   |
| `checkUsernameAvailability` | `(username) => Promise<WaUsernameAvailabilityResult>`                                | Disponibilidade + sugestões.                                                                                                                                                                                                                           |
| `setUsernameKey`            | `(pin) => Promise<boolean>`                                                          | Define o PIN de recuperação do username.                                                                                                                                                                                                               |
| `getAboutStatus`            | `(jid) => Promise<string \| null>`                                                   | Texto "Sobre" via MEX.                                                                                                                                                                                                                                 |
| `getLidsByPhoneNumbers`     | `(phoneNumbers) => Promise<readonly SignalLidSyncResult[]>`                          | Resolve [LIDs](/pt-br/concepts/identities#mapping-a-phone-number-to-its-lid) para números de telefone.                                                                                                                                                 |

***

<h2 id="status">
  status
</h2>

`WaStatusCoordinator` — veja [Broadcasts de status](/pt-br/guides/presence-status#status-broadcasts).

| Method         | Signature                                                       | Description                                  |
| -------------- | --------------------------------------------------------------- | -------------------------------------------- |
| `send`         | `(input: WaSendStatusInput) => Promise<WaMessagePublishResult>` | Publica um status para destinatários.        |
| `revokeStatus` | `(input) => Promise<WaMessagePublishResult>`                    | Revoga um status publicado.                  |
| `setPrivacy`   | `(input) => Promise<void>`                                      | Privacidade de status de toda a conta.       |
| `setUserMuted` | `(jid, muted) => Promise<void>`                                 | Silencia/dessilencia o status de um contato. |

***

<h2 id="broadcastlist">
  broadcastList
</h2>

`WaBroadcastListCoordinator`.

| Method       | Signature                                                                     | Description                                     |
| ------------ | ----------------------------------------------------------------------------- | ----------------------------------------------- |
| `setList`    | `(input: WaSetBroadcastListInput) => Promise<void>`                           | Cria/atualiza uma lista (nome + destinatários). |
| `removeList` | `(id) => Promise<void>`                                                       | Exclui uma lista.                               |
| `send`       | `(input: WaSendBroadcastListMessageInput) => Promise<WaMessagePublishResult>` | Envia para cada membro.                         |

<Warning>Listas de transmissão são **business-only** (apoiadas pelo schema de app-state `BusinessBroadcastList`); contas comuns têm as mutations rejeitadas.</Warning>

***

<h2 id="business">
  business
</h2>

`WaBusinessCoordinator` — veja [Business](/pt-br/guides/profile-privacy#business).

| Method                                 | Signature                                               | Description                                                                         |
| -------------------------------------- | ------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `getBusinessProfile`                   | `(jids) => Promise<readonly WaBusinessProfileResult[]>` | Perfis de business em lote (sobre, endereço, horários). Funciona de qualquer conta. |
| `getVerifiedName` / `getVerifiedNames` | `(jid) / (jids) => Promise<…>`                          | Consulta de nome verificado (único / em lote).                                      |
| `editBusinessProfile`                  | `(input) => Promise<void>`                              | Edita seu perfil de business. **Business-only.**                                    |
| `updateCoverPhoto`                     | `(media) => Promise<{ id }>`                            | Envia/vincula uma foto de capa. **Business-only.**                                  |
| `deleteCoverPhoto`                     | `(id) => Promise<void>`                                 | Exclui a foto de capa. **Business-only.**                                           |

***

<h2 id="bot">
  bot
</h2>

`WaBotCoordinator` — veja [Bots](/pt-br/guides/bots).

| Method            | Signature                                                    | Description                                                                                                            |
| ----------------- | ------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- |
| `listBots`        | `() => Promise<readonly WaBotInfo[]>`                        | Bots disponíveis à conta, agrupados por seção.                                                                         |
| `getBotProfile`   | `(jid, options?) => Promise<WaBotProfileResult \| null>`     | Perfil de um bot (comandos, prompts, criador).                                                                         |
| `sendPrompt`      | `(to, content, options?) => Promise<WaMessagePublishResult>` | Envia prompt a um bot — caminho direto (`to` é `@bot`) ou caminho de menção (grupo + `options.botJid`).                |
| `tryDecryptChunk` | `(event) => Promise<void>`                                   | Descriptografa um chunk de resposta em streaming → `message_bot_chunk`. Chamado automaticamente por mensagem recebida. |

***

<h2 id="email">
  email
</h2>

`WaEmailCoordinator`.

| Method                    | Signature                                     | Description                                       |
| ------------------------- | --------------------------------------------- | ------------------------------------------------- |
| `getStatus`               | `() => Promise<WaEmailStatus>`                | Vínculo atual (endereço + verificado/confirmado). |
| `setEmail`                | `(email, context?) => Promise<WaEmailStatus>` | Vincula/revincula um endereço.                    |
| `requestVerificationCode` | `(input) => Promise<void>`                    | Envia um código de verificação para o endereço.   |
| `verifyCode`              | `(code) => Promise<WaEmailVerifyCodeResult>`  | Submete o código enviado por e-mail.              |
| `confirm`                 | `(context?) => Promise<void>`                 | Confirmação de propriedade pós-verificação.       |

<Warning>O vínculo de e-mail é **mobile-only** — todo método lança em uma conexão Web/companion. Veja [Conexões mobile](/pt-br/concepts/mobile).</Warning>

***

<h2 id="mobile">
  mobile
</h2>

`WaMobileCoordinator` — veja [Hospedando dispositivos companheiros](/pt-br/concepts/mobile#hosting-companion-devices). Requer uma sessão mobile-primary; métodos de link/revoke/publish lançam em uma conexão Web/companion.

| Method                | Signature                                                  | Description                                                                                                                                         |
| --------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| `linkCompanion`       | `(qr) => Promise<LinkCompanionResult>`                     | Vincula um companion pela sua string de QR. Retorna `{ deviceJid, keyIndex }`.                                                                      |
| `linkCompanionByCode` | `(pairingCode) => Promise<LinkCompanionResult>`            | Vincula um companion pelo código de pareamento de 8 caracteres (o companion precisa ter solicitado um código para esta conta antes).                |
| `revokeCompanion`     | `(deviceJid, reason?) => Promise<void>`                    | Desvincula um companion hospedado e republica a key-index list. `reason` tem default `'user_initiated'`.                                            |
| `revokeAllCompanions` | `(reason?, { excludeHostedCompanion? }?) => Promise<void>` | "Log out all companion devices"; `excludeHostedCompanion` (opt-in) poupa os companions que esta conta hospeda.                                      |
| `listCompanions`      | `() => Promise<readonly CompanionRecord[]>`                | Os companions que este primary vinculou no epoch atual.                                                                                             |
| `reconcileCompanions` | `() => Promise<readonly string[]>`                         | Reconcilia o conjunto rastreado contra o servidor (`usync`); roda automaticamente no connect e em `account_sync`. Retorna os device jids removidos. |
| `publishKeyIndexList` | `() => Promise<void>`                                      | Re-assina e republica a key-index list para o conjunto atual de dispositivos.                                                                       |

***

<h2 id="lowlevel">
  lowlevel
</h2>

`WaLowLevelCoordinator` — referência completa em [API de baixo nível](/pt-br/reference/low-level): `sendNode`, `query`, `registerIncomingHandler`, `unregisterIncomingHandler`, `registerIncomingStanzaFilter`.

***

Para helpers de topo exportados da raiz do pacote — inspeção de mensagem (`getContentType`), normalização de target (`resolveMessageTarget`), predicados de JID e constantes — veja [JIDs, helpers & constantes](/pt-br/reference/jid-helpers). Para business hours tipados, veja [Perfil, privacidade & business](/pt-br/guides/profile-privacy#typed-business-hours).
