zapo-js 0.2.0 → 1.0.0

package/dist/types/media/{WaMediaTransferClient.d.ts → transfer/WaMediaTransferClient.d.ts}

@@ -1,11 +1,10 @@
-import { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaReadableDecryptionResult, WaMediaTransferClientOptions } from './types';
+import type { Readable } from 'node:stream';
+import type { MediaCryptoType, WaMediaReadableDecryptionResult, WaMediaTransferClientOptions } from '../types';
 interface StreamDownloadRequest {
     readonly url?: string;
     readonly directPath?: string;
     readonly hosts?: readonly string[];
     readonly headers?: Readonly<Record<string, string>>;
-    readonly dispatcher?: WaMediaTransferClientOptions['defaultDownloadDispatcher'];
     readonly agent?: WaMediaTransferClientOptions['defaultDownloadAgent'];
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
@@ -45,31 +44,53 @@ interface EncryptedDownloadRequest extends StreamDownloadRequest {
     readonly fileSha256?: Uint8Array;
     readonly fileEncSha256?: Uint8Array;
 }
+/**
+ * Streaming media uploader/downloader. Handles host failover, encryption
+ * (`WaMediaCrypto`), and MAC verification. Used internally by the message
+ * coordinator and exposed for direct media transfer use cases.
+ */
 export declare class WaMediaTransferClient {
     private readonly logger?;
     private readonly defaultHosts;
     private readonly defaultTimeoutMs;
     private readonly defaultMaxReadBytes;
     private readonly defaultHeaders;
-    private readonly defaultUploadDispatcher;
-    private readonly defaultDownloadDispatcher;
     private readonly defaultUploadAgent;
     private readonly defaultDownloadAgent;
-    private gotModulePromise;
+    private readonly skipMacVerification;
     constructor(options?: WaMediaTransferClientOptions);
+    /**
+     * Streams an encrypted media payload from the first responsive media host.
+     * Returns the raw transfer response – caller is responsible for piping the body.
+     */
     downloadStream(request: StreamDownloadRequest): Promise<StreamTransferResponse>;
+    /** Convenience wrapper: downloads the encrypted body and returns it as a Uint8Array. */
     downloadBytes(request: StreamDownloadRequest): Promise<Uint8Array>;
+    /**
+     * Uploads a raw (already-encrypted or plaintext) body to the requested
+     * media URL. Returns the server's transfer response unchanged.
+     */
     uploadStream(request: StreamUploadRequest): Promise<StreamTransferResponse>;
+    /**
+     * Encrypts the plaintext body with the per-`mediaType` HKDF keys (a new
+     * media key is generated when none is supplied) and uploads it. Returns
+     * the upload response plus the derived key/hashes for the message stanza.
+     */
     uploadEncrypted(request: EncryptedUploadRequest): Promise<EncryptedUploadResult>;
+    /**
+     * Downloads an encrypted media payload, decrypts it, and verifies the MAC
+     * + file SHA-256s. Returns the decrypted bytes.
+     */
     downloadAndDecrypt(request: EncryptedDownloadRequest): Promise<Uint8Array>;
+    /**
+     * Streaming variant of {@link downloadAndDecrypt}: returns a `plaintext`
+     * Readable plus a `metadata` promise that resolves after the stream ends
+     * with the verified hashes (or rejects on MAC/size failure).
+     */
     downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<WaMediaReadableDecryptionResult>;
+    /** Drains a streaming response body to a Uint8Array (respects `maxBytes`). */
     readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
-    private transferRequest;
-    private fetchWithDispatcher;
-    private toFetchTransferResponse;
-    private gotWithAgent;
-    private loadGotModule;
-    private toGotTransferResponse;
+    private httpRequest;
     private resolveTransferRequest;
     private prepareEncryptedUpload;
     private assertSuccessfulResponse;

package/dist/types/media/transfer/conn.d.ts

@@ -0,0 +1,7 @@
+import type { WaMediaConn } from '../types';
+import type { BinaryNode } from '../../transport/types';
+/**
+ * Parses a `media_conn` IQ response into a {@link WaMediaConn} (auth token,
+ * absolute expiry, and host list). Throws on missing auth/ttl/hosts.
+ */
+export declare function parseMediaConnResponse(node: BinaryNode, nowMs: number): WaMediaConn;

package/dist/types/media/types.d.ts

@@ -1,8 +1,8 @@
 import type { Readable } from 'node:stream';
 import type { Logger } from '../infra/log/types';
-import type { WaProxyAgent, WaProxyDispatcher } from '../transport/types';
+import type { WaProxyAgent } from '../transport/types';
 export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'ptv';
-export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'history' | 'md-app-state';
+export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'history' | 'md-app-state' | 'md-msg-hist' | 'xma-image' | 'sticker-pack' | 'thumbnail-sticker-pack' | 'thumbnail-link';
 export interface WaMediaConnHost {
     readonly hostname: string;
     readonly isFallback: boolean;
@@ -18,21 +18,21 @@ export interface WaMediaTransferClientOptions {
     readonly defaultTimeoutMs?: number;
     readonly defaultMaxReadBytes?: number;
     readonly defaultHeaders?: Readonly<Record<string, string>>;
-    readonly defaultUploadDispatcher?: WaProxyDispatcher;
-    readonly defaultDownloadDispatcher?: WaProxyDispatcher;
     readonly defaultUploadAgent?: WaProxyAgent;
     readonly defaultDownloadAgent?: WaProxyAgent;
+    readonly skipMacVerification?: boolean;
 }
 export interface WaMediaDerivedKeys {
     readonly iv: Uint8Array;
     readonly encKey: Uint8Array;
     readonly macKey: Uint8Array;
-    readonly refKey: Uint8Array;
 }
 export interface WaMediaEncryptionResult {
     readonly ciphertextHmac: Uint8Array;
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
+    readonly streamingSidecar?: Uint8Array;
+    readonly firstFrameSidecar?: Uint8Array;
 }
 export interface WaMediaDecryptionResult {
     readonly plaintext: Uint8Array;
@@ -45,6 +45,8 @@ export interface WaMediaReadableEncryptionResult {
         readonly fileSha256: Uint8Array;
         readonly fileEncSha256: Uint8Array;
         readonly plaintextLength: number;
+        readonly streamingSidecar?: Uint8Array;
+        readonly firstFrameSidecar?: Uint8Array;
     }>;
 }
 export interface WaMediaReadableDecryptionResult {
@@ -60,10 +62,13 @@ export interface WaMediaFileEncryptionResult {
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
     readonly plaintextLength: number;
+    readonly streamingSidecar?: Uint8Array;
+    readonly firstFrameSidecar?: Uint8Array;
 }
 export interface WaMediaDecryptReadableOptions {
     readonly mediaType: MediaCryptoType;
     readonly mediaKey: Uint8Array;
     readonly expectedFileSha256?: Uint8Array;
     readonly expectedFileEncSha256?: Uint8Array;
+    readonly skipMacVerification?: boolean;
 }

package/dist/types/message/WaMessageClient.d.ts

@@ -9,6 +9,11 @@ interface WaMessageClientOptions {
     readonly defaultMaxAttempts?: number;
     readonly defaultRetryDelayMs?: number;
 }
+/**
+ * Low-level message-publishing client. Sends pre-built message/receipt nodes,
+ * handles ack timeouts and retry on negative-ack failures, and is the
+ * transport hook used by {@link WaMessageCoordinator}.
+ */
 export declare class WaMessageClient {
     private readonly logger;
     private readonly sendNode;
@@ -17,11 +22,20 @@ export declare class WaMessageClient {
     private readonly defaultMaxAttempts;
     private readonly defaultRetryDelayMs;
     constructor(options: WaMessageClientOptions);
+    /**
+     * Publishes a `<message>` stanza and awaits its ack/receipt, retrying on
+     * retryable negative-ack errors up to `maxAttempts`. Returns the ack
+     * metadata extracted from the server response.
+     */
     publishNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    /** Builds the encrypted message envelope from `input` and publishes it via {@link publishNode}. */
     publishEncrypted(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    /** Fire-and-forget variant: sends a `<message>` stanza without awaiting an ack. */
     sendMessageNode(node: BinaryNode): Promise<void>;
+    /** Builds and sends an encrypted message envelope without awaiting an ack. */
     sendEncrypted(input: WaEncryptedMessageInput): Promise<void>;
     private buildEncryptedMessageNode;
+    /** Builds and sends a `<receipt>` stanza (delivery/read/played/etc.). */
     sendReceipt(input: WaSendReceiptInput): Promise<void>;
     private isRetryablePublishError;
     private extractAckMetadata;

package/dist/types/message/addons/link-preview/builder.d.ts

@@ -0,0 +1,13 @@
+import type { Proto } from '../../..';
+import type { WaLinkPreviewResolved } from './types';
+export interface WaLinkPreviewThumbnailFields {
+    readonly jpegThumbnail?: Uint8Array;
+    readonly thumbnailDirectPath?: string;
+    readonly thumbnailSha256?: Uint8Array;
+    readonly thumbnailEncSha256?: Uint8Array;
+    readonly mediaKey?: Uint8Array;
+    readonly mediaKeyTimestamp?: number;
+    readonly thumbnailWidth?: number;
+    readonly thumbnailHeight?: number;
+}
+export declare function buildExtendedTextWithPreview(text: string, resolved: WaLinkPreviewResolved, thumbnailFields: WaLinkPreviewThumbnailFields): Proto.IMessage;

package/dist/types/message/addons/link-preview/detect.d.ts

@@ -0,0 +1,5 @@
+export interface WaDetectedLink {
+    readonly matchedText: string;
+    readonly url: URL;
+}
+export declare function findFirstLink(text: string): WaDetectedLink | null;

package/dist/types/message/addons/link-preview/fetcher.d.ts

@@ -0,0 +1,13 @@
+import type { WaMediaTransferClient } from '../../../media/transfer/WaMediaTransferClient';
+import type { WaProxyTransport } from '../../../transport/types';
+import type { WaLinkPreviewFetcher } from './types';
+export interface DefaultLinkPreviewFetcherOptions {
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly userAgent?: string;
+    readonly fetchTimeoutMs?: number;
+    readonly maxHtmlBytes?: number;
+    readonly maxThumbnailBytes?: number;
+    readonly allowPrivateHosts?: boolean;
+    readonly proxy?: WaProxyTransport;
+}
+export declare function createDefaultLinkPreviewFetcher(options: DefaultLinkPreviewFetcherOptions): WaLinkPreviewFetcher;

package/dist/types/message/addons/link-preview/types.d.ts

@@ -0,0 +1,51 @@
+import type { Readable } from 'node:stream';
+import type { Logger } from '../../../infra/log/types';
+import type { proto } from '../../..';
+import type { WaProxyTransport } from '../../../transport/types';
+export type WaLinkPreviewType = proto.Message.ExtendedTextMessage.PreviewType;
+export interface WaLinkPreviewThumbnailBytes {
+    readonly bytes: Uint8Array;
+    readonly width?: number;
+    readonly height?: number;
+}
+export interface WaLinkPreviewThumbnailStream {
+    readonly stream: Readable;
+    readonly contentLength: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+export type WaLinkPreviewThumbnailInput = WaLinkPreviewThumbnailBytes | WaLinkPreviewThumbnailStream;
+export interface WaLinkPreviewOverride {
+    readonly matchedText?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly previewType?: WaLinkPreviewType;
+    readonly thumbnail?: WaLinkPreviewThumbnailInput;
+}
+export interface WaLinkPreviewResolved {
+    readonly matchedText: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly previewType: WaLinkPreviewType;
+    readonly thumbnail?: WaLinkPreviewThumbnailInput;
+}
+export interface WaLinkPreviewFetchInput {
+    readonly url: URL;
+    readonly matchedText: string;
+    readonly logger: Logger;
+    readonly signal?: AbortSignal;
+}
+export interface WaLinkPreviewFetcher {
+    fetch(input: WaLinkPreviewFetchInput): Promise<WaLinkPreviewResolved | null>;
+}
+export interface WaLinkPreviewOptions {
+    readonly enabled?: boolean;
+    readonly fetchTimeoutMs?: number;
+    readonly uploadHqThumbnail?: boolean;
+    readonly allowPrivateHosts?: boolean;
+    readonly maxHtmlBytes?: number;
+    readonly maxThumbnailBytes?: number;
+    readonly userAgent?: string;
+    readonly proxy?: WaProxyTransport;
+    readonly fetcher?: WaLinkPreviewFetcher;
+}

package/dist/types/message/context-info.d.ts

@@ -0,0 +1,66 @@
+import type { Proto } from '..';
+export interface WaSendContextInfo {
+    readonly quotedMessageId?: string;
+    readonly quotedParticipant?: string;
+    readonly quotedRemoteJid?: string;
+    readonly quotedMessage?: Proto.IMessage;
+    readonly isForwarded?: boolean;
+    readonly forwardingScore?: number;
+    readonly mentionedJids?: readonly string[];
+    readonly isSpoiler?: boolean;
+    readonly expirationSeconds?: number;
+    readonly groupSubject?: string;
+    readonly parentGroupJid?: string;
+    readonly raw?: Proto.IContextInfo;
+}
+export interface WaQuoteRef {
+    readonly id: string;
+    readonly participant?: string;
+    readonly remoteJid?: string;
+    readonly message?: Proto.IMessage;
+}
+export declare function buildContextInfoProto(input: WaSendContextInfo): Proto.IContextInfo;
+export declare function applyContextInfo(message: Proto.IMessage, ctx: WaSendContextInfo | null | undefined): Proto.IMessage;
+/**
+ * Reads the disappearing-message TTL (`contextInfo.expiration`) from the first
+ * submessage that carries it. Unwraps `ephemeralMessage` if present. Returns
+ * `undefined` when no submessage has an `expiration` set.
+ */
+export declare function pickIncomingExpirationSeconds(message: Proto.IMessage | undefined): number | undefined;
+/**
+ * Anything that identifies a quoted message. Accepts a {@link WaQuoteRef}, a
+ * {@link WaMessageKey} (bare proto key), or a full incoming message event (its
+ * `key` + `message` are read). All fields are optional structurally — the
+ * public `quote` option type enforces the concrete shape.
+ */
+type WaQuoteSource = {
+    readonly key?: {
+        readonly id?: string;
+        readonly remoteJid?: string;
+        readonly participant?: string;
+        readonly fromMe?: boolean;
+    };
+    readonly id?: string;
+    readonly remoteJid?: string;
+    readonly participant?: string;
+    readonly message?: Proto.IMessage;
+};
+type WaForwardSource = boolean | {
+    readonly score?: number;
+};
+export interface WaSendContextResolveInput {
+    readonly contentLevel?: WaSendContextInfo;
+    readonly optionsLevel?: WaSendContextInfo;
+    readonly quote?: WaQuoteSource;
+    readonly forward?: WaForwardSource;
+    readonly mentions?: readonly string[];
+    /**
+     * LID-form self user JID. Used as the DM-quote `participant` fallback when
+     * the quoted message is `fromMe` and no explicit participant was provided.
+     * Mirrors wa-web's `getSender(msg)` (returns `msg.from`, which for 1:1 is
+     * `fromMe ? me : peer`).
+     */
+    readonly meLid?: string;
+}
+export declare function resolveSendContextInfo(input: WaSendContextResolveInput): WaSendContextInfo | null;
+export {};

package/dist/types/message/crypto/addon-crypto.d.ts

@@ -0,0 +1,78 @@
+import type { WaAddonKind } from '../../client/types';
+import { WA_USE_CASE_SECRET_MODIFICATION_TYPES } from '../crypto/use-case-secret';
+import { type Proto } from '../..';
+import type { WaMessageSecretEntry, WaMessageSecretStore } from '../../store/contracts/message-secret.store';
+import type { WaMessageStore } from '../../store/contracts/message.store';
+type WaAddonBytes = Uint8Array | ArrayBuffer | ArrayBufferView;
+type ModificationType = (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+/** Returns `true` when an addon kind binds its AES-GCM ciphertext to additional data (polls + event responses). */
+export declare function shouldUseAddonAdditionalData(modificationType: ModificationType): boolean;
+/** Builds the canonical AES-GCM `additionalData` bytes for an addon (stanza id + NUL + sender). */
+export declare function buildAddonAdditionalData(stanzaId: string, addOnSenderJid: string): Uint8Array;
+/** Encrypts an addon payload (poll vote, reaction, edit, ...) with the per-use-case secret. */
+export declare function encryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: ModificationType;
+    readonly payload: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+/** Decrypts an addon payload encrypted with {@link encryptAddonPayload}. */
+export declare function decryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: ModificationType;
+    readonly ciphertext: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+export interface WaIdentifiedEncAddon {
+    readonly kind: WaAddonKind;
+    readonly targetMessageKey: Proto.IMessageKey;
+    readonly encPayload: Uint8Array;
+    readonly encIv: Uint8Array;
+    readonly modificationType: ModificationType;
+    readonly raw: Proto.IMessage;
+}
+/**
+ * Inspects a message and, when it contains an encrypted addon (reaction,
+ * poll vote, edit, comment, event response, ...), returns the parsed
+ * envelope with its kind and target message key. Returns `null` otherwise.
+ */
+export declare function identifyEncryptedAddon(message: Proto.IMessage): WaIdentifiedEncAddon | null;
+export type WaDecodedAddon = {
+    readonly kind: 'reaction';
+    readonly reaction: Proto.Message.IReactionMessage;
+} | {
+    readonly kind: 'poll_vote';
+    readonly pollVote: Proto.Message.IPollVoteMessage;
+    readonly selectedOptionNames: readonly string[] | null;
+} | {
+    readonly kind: 'event_response';
+    readonly eventResponse: Proto.Message.IEventResponseMessage;
+} | {
+    readonly kind: 'comment';
+    readonly comment: Proto.Message.ICommentMessage;
+} | {
+    readonly kind: 'message_edit';
+    readonly message: Proto.IMessage;
+} | {
+    readonly kind: 'event_edit';
+    readonly message: Proto.IMessage;
+} | {
+    readonly kind: 'poll_edit';
+    readonly message: Proto.IMessage;
+} | {
+    readonly kind: 'poll_add_option';
+    readonly message: Proto.IMessage;
+};
+/** Decodes the decrypted addon plaintext into its typed protobuf message based on `kind`. */
+export declare function decodeAddonPlaintext(kind: WaAddonKind, plaintext: Uint8Array): WaDecodedAddon;
+export declare function resolveParentMessageSecret(targetMessageId: string, messageSecretStore: WaMessageSecretStore, messageStore: WaMessageStore): Promise<WaMessageSecretEntry | null>;
+export declare function resolvePollOptionNames(selectedOptions: readonly Uint8Array[], pollCreationMessageId: string, messageStore: WaMessageStore): Promise<readonly string[] | null>;
+export {};

package/dist/types/message/{icdc.d.ts → crypto/icdc.d.ts}

@@ -1,13 +1,13 @@
-import type { Proto } from '..';
-import type { SignalAddress } from '../signal/types';
-import type { WaSignalStore } from '../store/contracts/signal.store';
+import type { Proto } from '../..';
+import type { SignalAddress } from '../../signal/types';
+import type { WaIdentityStore } from '../../store/contracts/identity.store';
 export interface IcdcMeta {
     readonly keyHash: Uint8Array;
     readonly timestamp: number | undefined;
 }
-export declare function computeDeviceKeyHash(identityKeys: readonly Uint8Array[]): Promise<Uint8Array>;
-export declare function resolveIcdcMeta(deviceJids: readonly string[], signalStore: WaSignalStore, updatedAtMs: number | undefined, localIdentity?: {
+export declare function computeDeviceKeyHash(identityKeys: readonly Uint8Array[], hashLength?: number): Uint8Array;
+export declare function resolveIcdcMeta(deviceJids: readonly string[], identityStore: WaIdentityStore, updatedAtMs: number | undefined, localIdentity?: {
     readonly address: SignalAddress;
     readonly pubKey: Uint8Array;
-}): Promise<IcdcMeta | null>;
+}, hashLength?: number): Promise<IcdcMeta | null>;
 export declare function injectDeviceListMetadata(message: Proto.IMessage, senderIcdc: IcdcMeta | null, recipientIcdc: IcdcMeta | null): Proto.IMessage;

package/dist/types/message/{phash.d.ts → crypto/phash.d.ts}

@@ -1 +1 @@
-export declare function computePhashV2(participants: readonly string[]): Promise<string>;
+export declare function computePhashV2(participants: readonly string[]): string;

package/dist/types/message/{reporting-token.d.ts → crypto/reporting-token.d.ts}

@@ -1,5 +1,5 @@
-import { type Proto } from '..';
-import type { BinaryNode } from '../transport/types';
+import { type Proto } from '../..';
+import type { BinaryNode } from '../../transport/types';
 export declare const WA_REPORTING_TOKEN_VERSION = 2;
 export interface BuildReportingTokenNodeInput {
     readonly message: Proto.IMessage;

package/dist/types/message/{use-case-secret.d.ts → crypto/use-case-secret.d.ts}

@@ -1,4 +1,4 @@
-import type { Proto } from '..';
+import type { Proto } from '../..';
 export declare const WA_MESSAGE_SECRET_BYTES = 32;
 export declare const WA_USE_CASE_SECRET_MODIFICATION_TYPES: Readonly<{
     readonly POLL_VOTE: "Poll Vote";
@@ -8,9 +8,25 @@ export declare const WA_USE_CASE_SECRET_MODIFICATION_TYPES: Readonly<{
     readonly EVENT_RESPONSE: "Event Response";
     readonly EVENT_EDIT_ENCRYPTED: "Event Edit";
     readonly MESSAGE_EDIT: "Message Edit";
+    readonly POLL_EDIT_ENCRYPTED: "Poll Edit";
+    readonly POLL_ADD_OPTION: "Poll Add Option";
 }>;
+/**
+ * Validates that `messageSecret` is exactly 32 bytes and returns it as a
+ * zero-copy Uint8Array view (throws otherwise).
+ */
 export declare function assertMessageSecret(messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView, context?: string): Uint8Array;
+/**
+ * Returns `message` unchanged when a message secret is already present;
+ * otherwise generates a fresh 32-byte secret and attaches it under
+ * `messageContextInfo.messageSecret`.
+ */
 export declare function ensureMessageSecret(message: Proto.IMessage): Promise<Proto.IMessage>;
+/**
+ * Derives the per-use-case secret (poll vote, reaction, edit, ...) via HKDF
+ * over `messageSecret` and the canonical `stanzaId + sender + sender +
+ * modificationType` info string.
+ */
 export declare function createUseCaseSecret(input: {
     readonly messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView;
     readonly stanzaId: string;

package/dist/types/message/encode/content.d.ts

@@ -0,0 +1,43 @@
+import type { WaMessageKey, WaMessageTargetInput, WaSendEventMessage, WaSendEventResponseMessage, WaSendKeepMessage, WaSendMediaMessage, WaSendPinMessage, WaSendPollMessage, WaSendPollVoteMessage, WaSendReactionMessage, WaSendRevokeMessage, WaSendTextMessage } from '../types';
+import { type Proto } from '../..';
+/**
+ * Returns the content-type key of a message - `'conversation'`,
+ * `'imageMessage'`, `'extendedTextMessage'`, etc. - or `undefined` for an empty
+ * message. `senderKeyDistributionMessage` is skipped so group messages report
+ * their real payload type rather than the piggy-backed sender-key.
+ */
+export declare function getContentType(content: Proto.IMessage | undefined): keyof Proto.IMessage | undefined;
+/**
+ * Normalizes a reply/edit/reaction/revoke/pin target into a {@link WaMessageKey}:
+ * an explicit key is returned as-is, while a received `message` event
+ * ({@link WaMessageRef}, identified by its `rawNode`) yields its pre-computed
+ * `key`.
+ */
+export declare function resolveMessageTarget(ref: WaMessageTargetInput): WaMessageKey;
+export declare function isSendMediaMessage(content: unknown): content is WaSendMediaMessage;
+export declare function isSendTextMessage(content: unknown): content is WaSendTextMessage;
+export declare function isSendReactionMessage(content: unknown): content is WaSendReactionMessage;
+export declare function isSendRevokeMessage(content: unknown): content is WaSendRevokeMessage;
+export declare function isSendPinMessage(content: unknown): content is WaSendPinMessage;
+export declare function isSendKeepMessage(content: unknown): content is WaSendKeepMessage;
+export declare function isSendPollMessage(content: unknown): content is WaSendPollMessage;
+export declare function isSendPollVoteMessage(content: unknown): content is WaSendPollVoteMessage;
+export declare function isSendEventMessage(content: unknown): content is WaSendEventMessage;
+export declare function isSendEventResponseMessage(content: unknown): content is WaSendEventResponseMessage;
+export declare function isSendAddonCryptoMessage(content: unknown): content is WaSendPollVoteMessage | WaSendEventResponseMessage;
+export declare function supportsViewOnce(message: Proto.IMessage): boolean;
+export declare function wrapAsViewOnce(message: Proto.IMessage): Proto.IMessage;
+export declare function unwrapMessage(message: Proto.IMessage): Proto.IMessage;
+export declare function resolveMessageTypeAttr(message: Proto.IMessage): string;
+export declare function resolveDecryptFailAttr(message: Proto.IMessage): 'hide' | undefined;
+export declare function needsSecretPersistence(message: Proto.IMessage): boolean;
+export declare function resolveEditAttr(message: Proto.IMessage): string | null;
+export declare function resolveEncMediaType(message: Proto.IMessage): string | null;
+export type WaButtonAddonKind = 'list' | 'interactive';
+export declare function resolveButtonAddonKind(message: Proto.IMessage): WaButtonAddonKind | null;
+export interface MessageMetaAttrs {
+    readonly polltype?: string;
+    readonly event_type?: string;
+    readonly view_once?: string;
+}
+export declare function resolveMetaAttrs(message: Proto.IMessage): MessageMetaAttrs | null;

package/dist/types/message/{device-sent.d.ts → encode/device-sent.d.ts}

@@ -1,3 +1,3 @@
-import type { Proto } from '..';
+import type { Proto } from '../..';
 export declare function wrapDeviceSentMessage(message: Proto.IMessage, destinationJid: string): Proto.IMessage;
 export declare function unwrapDeviceSentMessage(message: Proto.IMessage): Proto.IMessage | null;

package/dist/types/message/encode/media-payload.d.ts

@@ -0,0 +1,12 @@
+import type { MediaCryptoType } from '../../media/types';
+import type { Proto } from '../..';
+export interface WaResolvedMediaPayload {
+    readonly mediaType: MediaCryptoType;
+    readonly directPath: string;
+    readonly mediaKey: Uint8Array;
+    readonly fileSha256?: Uint8Array;
+    readonly fileEncSha256?: Uint8Array;
+    readonly mimetype?: string;
+    readonly fileLength?: number;
+}
+export declare function resolveMediaPayload(message: Proto.IMessage | null | undefined): WaResolvedMediaPayload | null;

package/dist/types/message/index.d.ts

@@ -1,4 +1,4 @@
 export { WaMessageClient } from './WaMessageClient';
-export * from './addon-crypto';
+export * from './crypto/addon-crypto';
 export * from './types';
-export * from './use-case-secret';
+export * from './crypto/use-case-secret';

package/dist/types/message/kinds/bot.d.ts

@@ -0,0 +1,31 @@
+import { proto, type Proto } from '../..';
+export declare function genBotMsgSecret(messageSecret: Uint8Array | ArrayBufferView): Uint8Array;
+export declare function deriveBotChunkKey(input: {
+    readonly botMsgSecret: Uint8Array | ArrayBufferView;
+    readonly saltId: string;
+    readonly targetSenderJid: string;
+    readonly authorJid: string;
+}): Uint8Array;
+export interface DecryptBotChunkInput {
+    readonly parentMessageSecret: Uint8Array | ArrayBufferView;
+    readonly saltId: string;
+    readonly targetSenderJid: string;
+    readonly authorJid: string;
+    readonly encIv: Uint8Array | ArrayBufferView;
+    readonly encPayload: Uint8Array | ArrayBufferView;
+}
+export declare function decryptBotChunk(input: DecryptBotChunkInput): Uint8Array;
+export interface WaBotMetadataInput {
+    readonly personaId?: string;
+    readonly invokerJid?: string;
+    readonly capabilities?: readonly proto.BotCapabilityMetadata.BotCapabilityType[];
+}
+export declare function attachBotMetadata(message: Proto.IMessage, input: WaBotMetadataInput): Proto.IMessage;
+export interface WaBotThreadInput {
+    readonly aiThreadId: string;
+    readonly remoteJid: string;
+    readonly threadType?: proto.AIThreadInfo.AIThreadClientInfo.AIThreadType;
+}
+export declare function attachBotThread(message: Proto.IMessage, input: WaBotThreadInput): Proto.IMessage;
+export declare function extractInvokedBotJid(message: Proto.IMessage): string | null;
+export declare function buildBotInvokeProtoCopy(message: Proto.IMessage, botMessageSecret?: Uint8Array): Proto.IMessage;

package/dist/types/message/kinds/newsletter.d.ts

@@ -0,0 +1,12 @@
+import type { WaIncomingMessageEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingUnhandledStanzaEvent } from '../../client/types';
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../../transport/types';
+interface ProcessNewsletterMessageOptions {
+    readonly logger: Logger;
+    readonly emitIncomingMessage?: (event: WaIncomingMessageEvent) => void;
+    readonly emitNewsletterMessageUpdate?: (event: WaIncomingNewsletterMessageUpdateEvent) => void;
+    readonly emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
+}
+export declare function processNewsletterLiveUpdates(notification: BinaryNode, options: ProcessNewsletterMessageOptions): void;
+export declare function processIncomingNewsletterMessage(node: BinaryNode, options: ProcessNewsletterMessageOptions): void;
+export {};

package/dist/types/message/kinds/sticker-pack.d.ts

@@ -0,0 +1,6 @@
+import { type StickerPackZipEntry } from '../../media/sticker/sticker-pack';
+import type { WaSendStickerPackMessage } from '../types';
+import type { Proto } from '../..';
+export declare function validateStickerPackInput(content: WaSendStickerPackMessage): void;
+export declare function toStickerPackZipEntries(content: WaSendStickerPackMessage): StickerPackZipEntry[];
+export declare function toStickerPackProtoStickers(content: WaSendStickerPackMessage): Proto.Message.StickerPackMessage.ISticker[];

package/dist/types/message/{ack.d.ts → primitives/ack.d.ts}

@@ -1,4 +1,4 @@
-import type { BinaryNode } from '../transport/types';
+import type { BinaryNode } from '../../transport/types';
 export declare function isAckOrReceiptNode(node: BinaryNode): boolean;
 export declare function isNegativeAckNode(node: BinaryNode): boolean;
 export declare function isRetryableNegativeAck(node: BinaryNode): boolean;

package/dist/types/message/primitives/incoming.d.ts

@@ -0,0 +1,21 @@
+import type { WaIncomingMessageEvent, WaIncomingNewsletterMessageUpdateEvent, WaIncomingUnhandledStanzaEvent } from '../../client/types';
+import type { Logger } from '../../infra/log/types';
+import { proto } from '../..';
+import type { WaRetryDecryptFailureContext } from '../../retry/types';
+import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
+import type { SignalProtocol } from '../../signal/session/SignalProtocol';
+import type { BinaryNode } from '../../transport/types';
+interface WaIncomingMessageAckHandlerOptions {
+    readonly logger: Logger;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly getMeJid?: () => string | null | undefined;
+    readonly signalProtocol?: SignalProtocol;
+    readonly senderKeyManager?: SenderKeyManager;
+    readonly onDecryptFailure?: (context: WaRetryDecryptFailureContext, error: unknown) => Promise<boolean>;
+    readonly emitIncomingMessage?: (event: WaIncomingMessageEvent) => void;
+    readonly emitNewsletterMessageUpdate?: (event: WaIncomingNewsletterMessageUpdateEvent) => void;
+    readonly emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
+}
+export declare function buildRecoveredIncomingEvent(webMessageInfo: proto.IWebMessageInfo): WaIncomingMessageEvent;
+export declare function handleIncomingMessageAck(node: BinaryNode, options: WaIncomingMessageAckHandlerOptions): Promise<boolean>;
+export {};