zapo-js 0.2.0 → 1.0.0

package/dist/types/client/coordinators/WaAppStateMutationCoordinator.d.ts

@@ -1,37 +1,248 @@
+import type { WaAppStateSyncClient } from '../../appstate/sync/WaAppStateSyncClient';
 import type { WaAppStateSyncOptions, WaAppStateSyncResult } from '../../appstate/types';
-import type { WaAppStateMessageKey, WaClearChatOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions } from '../types';
+import { type DataForKey, type WaAppstateActionKey, type WaAppstateIndexArgs } from '../..';
+import type { WaAppStateMessageKey, WaAppStateMutationEvent, WaClearChatOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions } from '../types';
 import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import { proto, type Proto } from '../..';
+import type { WaStoredContactRecord } from '../../store/contracts/contact.store';
 import type { WaMessageStore } from '../../store/contracts/message.store';
+import type { ServerClock } from '../../util/clock';
+type StatusDistributionMode = Proto.SyncActionValue.StatusPrivacyAction.StatusDistributionMode;
+type StatusDistributionModeKey = keyof typeof proto.SyncActionValue.StatusPrivacyAction.StatusDistributionMode;
+type SetMutationInputFor<K extends WaAppstateActionKey> = K extends K ? {
+    readonly schema: K;
+} & WaAppstateIndexArgs<K> & Partial<DataForKey<K>> : never;
+type RemoveMutationInputFor<K extends WaAppstateActionKey> = K extends K ? {
+    readonly schema: K;
+} & WaAppstateIndexArgs<K> : never;
+export interface WaSetMutationInputMap {
+    readonly _: SetMutationInputFor<WaAppstateActionKey>;
+}
+export interface WaRemoveMutationInputMap {
+    readonly _: RemoveMutationInputFor<WaAppstateActionKey>;
+}
+export type WaSetMutationInput = WaSetMutationInputMap['_'];
+export type WaRemoveMutationInput = WaRemoveMutationInputMap['_'];
 interface WaAppStateMutationCoordinatorOptions {
     readonly logger: Logger;
     readonly messageStore: WaMessageStore;
-    readonly syncAppState: (options?: WaAppStateSyncOptions) => Promise<WaAppStateSyncResult>;
+    readonly appStateSync: WaAppStateSyncClient;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly isConnected: () => boolean;
+    readonly serverClock: ServerClock;
     readonly archiveRangeLimit?: number;
+    readonly emitMutation?: (event: WaAppStateMutationEvent) => void;
+    readonly emitSnapshotMutations?: boolean;
+    readonly nctSaltSink?: (salt: Uint8Array | null) => Promise<void>;
+    /**
+     * Persistence sink for `Contact` collection mutations (the locally-saved
+     * address-book name the primary device synced over app-state). Invoked on
+     * every winning mutation including snapshot ones, so the contact store is
+     * bootstrapped at pair-time regardless of `emitSnapshotMutations`.
+     */
+    readonly contactSink?: (record: WaStoredContactRecord) => void;
+}
+export interface WaSetStatusPrivacyInput {
+    readonly mode: StatusDistributionModeKey | StatusDistributionMode;
+    readonly userJids?: readonly string[];
+    readonly shareToFB?: boolean;
+    readonly shareToIG?: boolean;
+}
+export interface WaBroadcastListParticipant {
+    readonly lidJid: string;
+    readonly pnJid?: string;
+}
+export interface WaSetBroadcastListInput {
+    readonly id: string;
+    readonly listName: string;
+    readonly participants: readonly WaBroadcastListParticipant[];
+    readonly labelIds?: readonly string[];
 }
+/**
+ * Coordinates app-state mutations (mute/star/read/pin/archive/clear/delete/
+ * lock chats, status privacy, broadcast lists) and emits parsed mutation
+ * events on sync. Accessed via {@link WaClient.chat}.
+ */
 export declare class WaAppStateMutationCoordinator {
     private readonly logger;
     private readonly messageStore;
-    private readonly syncAppState;
+    private readonly appStateSync;
+    private readonly mediaTransfer;
+    private readonly isConnected;
+    private readonly serverClock;
     private readonly archiveRangeLimit;
+    private readonly emitMutation?;
+    private readonly emitSnapshotMutations;
+    private readonly nctSaltSink?;
+    private readonly contactSink?;
     private readonly pendingMutations;
     private flushPromise;
     constructor(options: WaAppStateMutationCoordinatorOptions);
+    /**
+     * Runs an app-state sync round, optionally applying pending mutations.
+     * Throws when the client is not connected. Returns the per-collection
+     * result; blocked collections are logged.
+     */
+    sync(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
+    /** Returns the names of collections reported as `BLOCKED` in `syncResult`. */
+    getBlockedCollections(syncResult: WaAppStateSyncResult): readonly string[];
+    /**
+     * Walks a sync result and emits one `app_state_mutation` event per
+     * distinct (collection, index) – only the last mutation per key wins.
+     * Snapshot-source mutations are skipped unless `emitSnapshotMutations`
+     * was enabled at construction.
+     */
+    emitEventsFromSyncResult(syncResult: WaAppStateSyncResult): void;
+    private handleNctSaltMutation;
+    private handleContactMutation;
+    /**
+     * Mutes or unmutes a chat. `muteEndTimestampMs` is required when
+     * `muted` is `true` and must be a non-negative safe-integer epoch.
+     *
+     * For a "mute forever" entry, pass a very large epoch value (the
+     * official client uses year-9999 epochs). The mute end is the absolute
+     * timestamp when WhatsApp will re-enable notifications - the client
+     * does **not** unmute automatically when the timer expires (you'll see
+     * the chat un-muted on the phone, but no `mutation` event re-fires).
+     */
     setChatMute(chatJid: string, muted: boolean, muteEndTimestampMs?: number): Promise<void>;
+    /** Stars or un-stars a specific message. */
     setMessageStar(message: WaAppStateMessageKey, starred: boolean): Promise<void>;
+    /** Marks the chat as read or unread. */
     setChatRead(chatJid: string, read: boolean): Promise<void>;
+    /**
+     * Pins or unpins the chat. Pinning also clears any active archive flag
+     * (the two states are mutually exclusive on the client). WhatsApp
+     * imposes a server-side cap on pinned chats - extra pins sync but the
+     * official UI will hide / reject them.
+     */
     setChatPin(chatJid: string, pinned: boolean): Promise<void>;
+    /** Archives or unarchives the chat. Archiving also clears any pin. */
     setChatArchive(chatJid: string, archived: boolean): Promise<void>;
+    /**
+     * Clears the chat history (without deleting the chat itself - it stays
+     * in the chat list, just empty). Defaults to **preserving** starred
+     * messages and media; set `options.deleteStarred`/`deleteMedia` to wipe
+     * those too. The clear is local-only - other participants keep their
+     * copies.
+     */
     clearChat(chatJid: string, options?: WaClearChatOptions): Promise<void>;
+    /**
+     * Deletes the chat entirely (removes from the chat list + drops every
+     * stored message). Local-only - the conversation continues to exist on
+     * the peer's device. For groups, this does **not** leave the group;
+     * use {@link WaGroupCoordinator.leaveGroup} for that.
+     */
     deleteChat(chatJid: string, options?: WaDeleteChatOptions): Promise<void>;
+    /**
+     * Deletes a single message **locally** - removes it from your own
+     * device(s) only. The recipient(s) still see it. Use a `revoke`
+     * outgoing message ({@link WaMessageCoordinator.send} with
+     * `{ type: 'revoke', ... }`) to delete-for-everyone instead.
+     * `messageTimestampMs` must be a non-negative safe-integer epoch when set.
+     */
     deleteMessageForMe(message: WaAppStateMessageKey, options?: WaDeleteMessageForMeOptions): Promise<void>;
+    /** Locks or unlocks the chat. Locking also clears archive and pin. */
     setChatLock(chatJid: string, locked: boolean): Promise<void>;
+    /**
+     * Drains any queued mutations through a sync round. Concurrent callers
+     * share the in-flight flush promise. Failed collections are re-queued
+     * before the error is rethrown.
+     */
     flushMutations(): Promise<void>;
     private enqueueAndFlush;
     private enqueueMutation;
     private takePendingMutationsBatch;
     private flushPendingMutationsLoop;
     private requeueMutations;
-    private createSetMutation;
+    /**
+     * Sets the account-wide status-broadcast distribution policy. `mode`
+     * accepts either the proto enum number or its string name; allow/deny
+     * lists are provided via `userJids`.
+     */
+    setStatusPrivacy(input: WaSetStatusPrivacyInput): Promise<void>;
+    /** Mutes/unmutes a single user's status broadcasts. Rejects group/broadcast JIDs. */
+    setUserStatusMute(jid: string, muted: boolean): Promise<void>;
+    /** Creates or updates the broadcast list identified by `input.id`. */
+    setBroadcastList(input: WaSetBroadcastListInput): Promise<void>;
+    /** Deletes the broadcast list identified by `id`. */
+    removeBroadcastList(id: string): Promise<void>;
+    /**
+     * Applies a `set` mutation against any registered app-state schema. This
+     * is the way to reach schemas that don't have a typed helper on this
+     * coordinator (Contact, LabelEdit, LabelJid, QuickReply, AiThreadPin,
+     * Favorites, Nux, ...). For the common chat actions there's a dedicated
+     * method ({@link setChatMute}, {@link setChatRead}, {@link setMessageStar},
+     * {@link setChatPin}, {@link setChatArchive}, etc.) – use those instead.
+     *
+     * `input` is flat – pick a `schema` name from {@link WA_APPSTATE_SCHEMAS},
+     * fill the index fields (`id`, `chatJid`, `labelId`, ...) and the value
+     * fields side-by-side, and the coordinator routes them to the right
+     * SyncActionValue subfield.
+     *
+     * @example
+     * ```ts
+     * // Add a contact to the address book
+     * await client.chat.set({
+     *     schema: 'Contact',
+     *     id: '5511999999999@s.whatsapp.net',
+     *     contactAction: { fullName: 'Maria Silva', firstName: 'Maria' }
+     * })
+     *
+     * // Create a chat label (color is a server-side palette index)
+     * await client.chat.set({
+     *     schema: 'LabelEdit',
+     *     id: 'label-1',
+     *     labelEditAction: { name: 'Pendente', color: 0, isActive: true }
+     * })
+     *
+     * // Apply that label to a chat
+     * await client.chat.set({
+     *     schema: 'LabelJid',
+     *     labelId: 'label-1',
+     *     chatJid: '5511999999999@s.whatsapp.net',
+     *     labelAssociationAction: { labeled: true }
+     * })
+     *
+     * // Save a business quick reply
+     * await client.chat.set({
+     *     schema: 'QuickReply',
+     *     id: 'qr-greeting',
+     *     quickReplyAction: { shortcut: '/oi', message: 'Olá! Tudo bem?' }
+     * })
+     * ```
+     */
+    set(input: WaSetMutationInput): Promise<void>;
+    /**
+     * Applies a `remove` mutation against any registered app-state schema  -
+     * same shape as {@link set} but without the value fields (only the schema
+     * name + index args). Use this for schemas without a typed helper.
+     *
+     * @example
+     * ```ts
+     * // Drop a contact from the address book
+     * await client.chat.remove({
+     *     schema: 'Contact',
+     *     id: '5511999999999@s.whatsapp.net'
+     * })
+     *
+     * // Remove a label from a chat (the label itself stays – use LabelEdit
+     * // with `deleted: true` to delete the label definition entirely)
+     * await client.chat.remove({
+     *     schema: 'LabelJid',
+     *     labelId: 'label-1',
+     *     chatJid: '5511999999999@s.whatsapp.net'
+     * })
+     *
+     * // Delete a quick reply
+     * await client.chat.remove({
+     *     schema: 'QuickReply',
+     *     id: 'qr-greeting'
+     * })
+     * ```
+     */
+    remove(input: WaRemoveMutationInput): Promise<void>;
     private createArchiveMutation;
     private buildChatMessageRange;
     private toChatMessageRangeMessage;
@@ -40,7 +251,6 @@ export declare class WaAppStateMutationCoordinator {
     private normalizeChatMutationJid;
     private buildMessageMutationIndex;
     private resolveMessageMutationParticipant;
-    private buildMutationIndex;
     private describeMutationActions;
 }
 export {};

package/dist/types/client/coordinators/WaBotCoordinator.d.ts

@@ -0,0 +1,117 @@
+import type { WaAuthCredentials } from '../../auth/types';
+import type { WaIncomingBotChunkEvent, WaIncomingMessageEvent, WaSendMessageOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMessageBuildResult, WaMessagePublishResult, WaSendMessageContent } from '../../message/types';
+import { proto } from '../..';
+import type { WaMessageSecretStore } from '../../store/contracts/message-secret.store';
+import type { WaMessageStore } from '../../store/contracts/message.store';
+import type { BinaryNode } from '../../transport/types';
+export interface WaBotInfo {
+    readonly jid: string;
+    readonly fbidJid: string;
+    readonly personaId: string;
+    readonly isDefault: boolean;
+    readonly section?: string;
+    readonly count?: number;
+}
+export interface WaBotProfilePrompt {
+    readonly emoji: string;
+    readonly text: string;
+}
+export interface WaBotProfileCommand {
+    readonly name: string;
+    readonly description: string;
+}
+export type WaBotPosingAsProfessional = 'unknown' | 'yes' | 'no';
+export interface WaBotProfileResult {
+    readonly name: string | null;
+    readonly attributes: string | null;
+    readonly description: string | null;
+    readonly category: string | null;
+    readonly isDefault: boolean;
+    readonly prompts: readonly WaBotProfilePrompt[];
+    readonly personaId: string | null;
+    readonly commands: readonly WaBotProfileCommand[];
+    readonly commandsDescription: string | null;
+    readonly isMetaCreated: boolean | null;
+    readonly creatorName: string | null;
+    readonly creatorProfileUrl: string | null;
+    readonly posingAsProfessional: WaBotPosingAsProfessional | null;
+}
+export interface WaGetBotProfileOptions {
+    readonly personaId?: string;
+}
+export interface WaBotPromptOptions extends WaSendMessageOptions {
+    readonly botJid?: string;
+    readonly personaId?: string;
+    readonly capabilities?: readonly proto.BotCapabilityMetadata.BotCapabilityType[];
+    readonly extraMentionedJids?: readonly string[];
+    readonly aiThreadId?: string;
+    readonly aiThreadType?: proto.AIThreadInfo.AIThreadClientInfo.AIThreadType;
+}
+/**
+ * Coordinates Meta-AI bot discovery, profile lookup, prompt send, and
+ * streaming chunk decryption. Accessed via {@link WaClient.bot}.
+ */
+export interface WaBotCoordinator {
+    /** Lists the bots available to the current account, grouped by section. */
+    readonly listBots: () => Promise<readonly WaBotInfo[]>;
+    /** Fetches a single bot's profile (commands, prompts, creator metadata). */
+    readonly getBotProfile: (jid: string, options?: WaGetBotProfileOptions) => Promise<WaBotProfileResult | null>;
+    /**
+     * Sends a prompt to a bot. When `to` is a `@bot` JID this uses the
+     * direct path; for a group/chat JID, set `options.botJid` to invoke
+     * the bot via mention.
+     *
+     * **Where do I get a bot JID?**
+     * - Call {@link listBots} - returns one entry per available bot with
+     *   both `jid` (the `@bot` JID for direct sends) and `fbidJid` (the
+     *   form for `options.botJid` on the mention path).
+     * - Use the `WA_BOT_KNOWN_JIDS` constants from `zapo-js/protocol`
+     *   when you know the target (`META_AI_PN`, `META_AI_FBID`,
+     *   `MANUS_FBID`, `HATCH_FBID`, ...). No IQ required.
+     * - Read it off an incoming `message` event whose sender is a bot
+     *   (reply scenario).
+     *
+     * **Direct path** (`to` is a `@bot` JID): generates a fresh
+     * `aiThreadId` unless one is reused via `options.aiThreadId`,
+     * attaches the bot metadata + thread proto, and sends to the bot's
+     * FBID JID. Subsequent prompts using the same `aiThreadId` keep the
+     * conversation context.
+     *
+     * **Mention path** (`to` is a group/chat JID): `options.botJid`
+     * **must** be set. The bot is invoked indirectly; the lib strips
+     * persona/invoker/capabilities/threadInfo from the inner message
+     * because Meta AI silently drops the request when those are present
+     * on the mention path. `options.aiThreadId` and `options.aiThreadType`
+     * are ignored here.
+     */
+    readonly sendPrompt: (to: string, content: WaSendMessageContent, options?: WaBotPromptOptions) => Promise<WaMessagePublishResult>;
+    /**
+     * Attempts to decrypt a streaming bot chunk attached to `event` and,
+     * on success, emits a typed `WaIncomingBotChunkEvent`. Silently
+     * returns when the chunk is not addressed to the current account or
+     * the parent prompt secret is not available.
+     *
+     * **Called automatically by {@link WaClient} on every incoming
+     * message** - you rarely need to invoke it directly. Multiple chunks
+     * arrive per response; concatenate them in arrival order using the
+     * `editType` field (`first` → `inner` → `last`, or a single `full`)
+     * to reconstruct the full reply.
+     */
+    readonly tryDecryptChunk: (event: WaIncomingMessageEvent) => Promise<void>;
+}
+interface WaBotCoordinatorOptions {
+    readonly logger: Logger;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly buildMessageContent: (content: WaSendMessageContent) => Promise<WaMessageBuildResult>;
+    readonly sendMessage: (to: string, content: WaSendMessageContent, options?: WaSendMessageOptions) => Promise<WaMessagePublishResult>;
+    readonly messageStore: WaMessageStore;
+    readonly messageSecretStore: WaMessageSecretStore;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
+    readonly emitBotChunk: (event: WaIncomingBotChunkEvent) => void;
+    readonly generateSid: () => Promise<string>;
+}
+/** Builds a {@link WaBotCoordinator} from its IQ/message/store dependencies. */
+export declare function createBotCoordinator(options: WaBotCoordinatorOptions): WaBotCoordinator;
+export {};

package/dist/types/client/coordinators/WaBroadcastListCoordinator.d.ts

@@ -0,0 +1,39 @@
+import type { WaAppStateMutationCoordinator, WaSetBroadcastListInput } from '../coordinators/WaAppStateMutationCoordinator';
+import type { WaSendMessageOptions } from '../types';
+import type { WaMessageBuildResult, WaMessagePublishResult, WaSendMessageContent } from '../../message/types';
+import type { Proto } from '../..';
+export interface WaBroadcastListCoordinatorOptions {
+    readonly appStateMutations: WaAppStateMutationCoordinator;
+    readonly buildMessageContent: (content: WaSendMessageContent) => Promise<WaMessageBuildResult>;
+    readonly publishBroadcastListMessage: (input: {
+        readonly listJid: string;
+        readonly message: Proto.IMessage;
+        readonly recipients: readonly string[];
+        readonly options?: WaSendMessageOptions;
+    }) => Promise<WaMessagePublishResult>;
+}
+export interface WaSendBroadcastListMessageInput {
+    readonly listJid: string;
+    readonly content: WaSendMessageContent;
+    readonly recipients: readonly string[];
+    readonly options?: WaSendMessageOptions;
+}
+/**
+ * Manages broadcast lists and dispatches messages to one. Accessed via
+ * {@link WaClient.broadcastList}.
+ *
+ * **Business-only.** Broadcast lists are backed by the
+ * `BusinessBroadcastList` app-state schema and are only available on
+ * WhatsApp Business accounts - regular accounts will see the underlying
+ * mutation IQs rejected by the server.
+ */
+export interface WaBroadcastListCoordinator {
+    /** Creates or updates a broadcast list definition (name + recipients). */
+    readonly setList: (input: WaSetBroadcastListInput) => Promise<void>;
+    /** Deletes a broadcast list by id. */
+    readonly removeList: (id: string) => Promise<void>;
+    /** Sends a message to every member of a broadcast list. */
+    readonly send: (input: WaSendBroadcastListMessageInput) => Promise<WaMessagePublishResult>;
+}
+/** Builds a {@link WaBroadcastListCoordinator} from its dependencies. */
+export declare function createBroadcastListCoordinator(options: WaBroadcastListCoordinatorOptions): WaBroadcastListCoordinator;

package/dist/types/client/coordinators/WaBusinessCoordinator.d.ts

@@ -1,57 +1,58 @@
-import type { WaEditBusinessProfileInput } from '../../transport/node/builders/business';
+import { type WaUploadMediaSource } from '../media';
+import type { WaBusinessProfileResult, WaVerifiedNameResult } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../../media/types';
+import { type WaEditBusinessProfileInput } from '../../transport/node/builders/business';
 import type { BinaryNode } from '../../transport/types';
-export interface WaBusinessCategory {
-    readonly id: string;
-    readonly name: string;
-}
-export interface WaBusinessHoursEntry {
-    readonly dayOfWeek: string;
-    readonly mode: string;
-    readonly openTime?: number;
-    readonly closeTime?: number;
-}
-export interface WaBusinessHours {
-    readonly timezone?: string;
-    readonly config: readonly WaBusinessHoursEntry[];
-}
-export interface WaBusinessWebsite {
-    readonly url: string;
-}
-export interface WaBusinessProfileResult {
+export interface WaVerifiedNameBatchEntry {
     readonly jid: string;
-    readonly tag?: string;
-    readonly description?: string;
-    readonly address?: string;
-    readonly email?: string;
-    readonly websites?: readonly WaBusinessWebsite[];
-    readonly categories?: readonly WaBusinessCategory[];
-    readonly businessHours?: WaBusinessHours;
-    readonly latitude?: number;
-    readonly longitude?: number;
-    readonly profileOptions?: Readonly<Record<string, string>>;
-}
-export interface WaVerifiedNamePrivacyMode {
-    readonly actualActors: number;
-    readonly hostStorage: number;
-    readonly privacyModeTs: number;
-}
-export interface WaVerifiedNameResult {
-    readonly name?: string;
-    readonly level?: string;
-    readonly serial?: string;
-    readonly isApi: boolean;
-    readonly isSmb: boolean;
-    readonly privacyMode?: WaVerifiedNamePrivacyMode;
-}
+    readonly verifiedName: WaVerifiedNameResult | null;
+}
+/**
+ * Coordinates WhatsApp Business profile reads/writes (profile body, verified
+ * name, cover photo). Accessed via {@link WaClient.business}.
+ *
+ * Read methods (`getBusinessProfile`, `getVerifiedName`, `getVerifiedNames`)
+ * work from any account. Write methods (`editBusinessProfile`,
+ * `updateCoverPhoto`, `deleteCoverPhoto`) are **business-only**: they target
+ * the current account's own business profile and the server rejects them
+ * when the account is not registered as a WhatsApp Business account.
+ */
 export interface WaBusinessCoordinator {
+    /** Batched fetch of business profile bodies (about, address, hours, ...). */
     readonly getBusinessProfile: (jids: readonly string[]) => Promise<readonly WaBusinessProfileResult[]>;
+    /**
+     * Edits the current account's business profile. **Business-only** - throws
+     * on regular WhatsApp accounts.
+     */
     readonly editBusinessProfile: (input: WaEditBusinessProfileInput) => Promise<void>;
+    /** Fetches a single business verified-name record (or `null`). */
     readonly getVerifiedName: (jid: string) => Promise<WaVerifiedNameResult | null>;
-    readonly updateCoverPhoto: (id: string, timestamp: string, token: string) => Promise<void>;
+    /** Batched verified-name lookup over many JIDs (usync). */
+    readonly getVerifiedNames: (jids: readonly string[]) => Promise<readonly WaVerifiedNameBatchEntry[]>;
+    /**
+     * Uploads and binds a new business cover photo. Returns the server-side
+     * upload id – feed it back into {@link deleteCoverPhoto} to remove the
+     * cover later. **Business-only** - throws on regular WhatsApp accounts.
+     */
+    readonly updateCoverPhoto: (media: WaUploadMediaSource) => Promise<{
+        readonly id: string;
+    }>;
+    /**
+     * Deletes the business cover photo by upload id (returned from
+     * {@link updateCoverPhoto}). **Business-only** - throws on regular
+     * WhatsApp accounts.
+     */
     readonly deleteCoverPhoto: (id: string) => Promise<void>;
 }
 interface WaBusinessCoordinatorOptions {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly getMediaConn: () => Promise<WaMediaConn>;
+    readonly logger: Logger;
+    readonly generateSid: () => Promise<string>;
 }
+/** Builds a {@link WaBusinessCoordinator} from its IQ/media dependencies. */
 export declare function createBusinessCoordinator(options: WaBusinessCoordinatorOptions): WaBusinessCoordinator;
 export {};

package/dist/types/client/coordinators/WaEmailCoordinator.d.ts

@@ -0,0 +1,40 @@
+import { type WaEmailContext } from '../../protocol/email';
+import { type BuildRequestEmailVerificationCodeInput } from '../../transport/node/builders/email';
+import type { BinaryNode } from '../../transport/types';
+export interface WaEmailStatus {
+    readonly email: string | null;
+    readonly verified: boolean;
+    readonly confirmed: boolean;
+}
+export interface WaEmailVerifyCodeResult {
+    readonly verified: boolean;
+    readonly autoVerifyFailed: boolean;
+    readonly email: string | null;
+}
+/**
+ * Coordinates the email-on-account flow: read state, bind/unbind, request
+ * verification code, submit the code, and confirm. Accessed via
+ * {@link WaClient.email}.
+ *
+ * **Mobile-only.** Email binding is only available when the client is
+ * connected via the WhatsApp Mobile transport (`options.mobileTransport`).
+ * Every method throws against a regular Web/companion connection because
+ * the server rejects the underlying IQ.
+ */
+export interface WaEmailCoordinator {
+    /** Returns the current email binding (address + verified/confirmed flags). */
+    readonly getStatus: () => Promise<WaEmailStatus>;
+    /** Binds (or rebinds) an email address to the account. */
+    readonly setEmail: (email: string, context?: WaEmailContext) => Promise<WaEmailStatus>;
+    /** Asks the server to send a verification code to the bound address. */
+    readonly requestVerificationCode: (input: BuildRequestEmailVerificationCodeInput) => Promise<void>;
+    /** Submits a verification code received via email. */
+    readonly verifyCode: (code: string) => Promise<WaEmailVerifyCodeResult>;
+    /** Confirms email ownership (post-verification handshake). */
+    readonly confirm: (context?: WaEmailContext) => Promise<void>;
+}
+export interface WaEmailCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+/** Builds a {@link WaEmailCoordinator} backed by the given IQ query function. */
+export declare function createEmailCoordinator(options: WaEmailCoordinatorOptions): WaEmailCoordinator;