zapo-js 0.1.1 → 0.2.0

package/dist/types/index.d.ts

@@ -1,10 +1,12 @@
 export { WaClient } from '@client';
-export type { WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from '@client';
+export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaWriteBehindOptions } from '@client';
+export type { WaBlocklistResult, WaPrivacyCoordinator, WaPrivacyDisallowedListResult, WaPrivacySettings } from './client/coordinators/WaPrivacyCoordinator';
 export { ConsoleLogger } from './infra/log/ConsoleLogger';
 export { PinoLogger, createPinoLogger } from './infra/log/PinoLogger';
 export type { PinoLoggerOptions } from './infra/log/PinoLogger';
 export type { Logger, LogLevel } from './infra/log/types';
 export { createStore } from '@store';
-export type { WaAppStateCollectionStoreState, WaAppStateStore, WaAuthStore, WaContactStore, WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSignalStore, WaSqliteDriver, WaSqliteStorageOptions, WaStoredContactRecord, WaStoredMessageRecord, WaStoredThreadRecord, WaStore, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession, WaThreadStore } from '@store';
-export { getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_XMLNS } from '@protocol';
+export type { WaAppStateCollectionStoreState, WaAppStateStore, WaAuthStore, WaContactStore, WaCreateStoreOptions, WaDeviceListSnapshot, WaDeviceListStore, WaMessageStore, WaParticipantsSnapshot, WaParticipantsStore, WaRetryStore, WaSenderKeyStore, WaSignalStore, WaStoredContactRecord, WaStoredMessageRecord, WaStoredThreadRecord, WaStore, WaStoreBackend, WaStoreSession, WaThreadStore } from '@store';
+export { getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES, WA_XMLNS } from '@protocol';
+export type { WaPrivacyCategory, WaPrivacySettingName, WaPrivacyValue } from '@protocol';
 export { proto } from '.';

package/dist/types/infra/log/ConsoleLogger.d.ts

@@ -1,11 +1,12 @@
 import type { LogLevel, Logger } from '../log/types';
 export declare class ConsoleLogger implements Logger {
     readonly level: LogLevel;
+    private readonly minLevelPriority;
     constructor(level?: LogLevel);
     trace(message: string, context?: Record<string, unknown>): void;
     debug(message: string, context?: Record<string, unknown>): void;
     info(message: string, context?: Record<string, unknown>): void;
     warn(message: string, context?: Record<string, unknown>): void;
     error(message: string, context?: Record<string, unknown>): void;
-    private canLog;
+    private write;
 }

package/dist/types/infra/log/PinoLogger.d.ts

@@ -24,7 +24,7 @@ export declare class PinoLogger implements Logger {
     info(message: string, context?: Readonly<Record<string, unknown>>): void;
     warn(message: string, context?: Readonly<Record<string, unknown>>): void;
     error(message: string, context?: Readonly<Record<string, unknown>>): void;
-    private writeLog;
+    private write;
 }
 export declare function createPinoLogger(options?: PinoLoggerOptions): Promise<PinoLogger>;
 export {};

package/dist/types/infra/log/types.d.ts

@@ -7,3 +7,4 @@ export interface Logger {
     warn(message: string, context?: Readonly<Record<string, unknown>>): void;
     error(message: string, context?: Readonly<Record<string, unknown>>): void;
 }
+export declare function createNoopLogger(level?: LogLevel): Logger;

package/dist/types/infra/perf/BackgroundQueue.d.ts

@@ -0,0 +1,58 @@
+export interface BackgroundQueueOptions<K extends string, V> {
+    readonly coalesce?: (previous: V, incoming: V, key: K) => V;
+    readonly maxPendingKeys?: number;
+    readonly maxWriteConcurrency?: number;
+    readonly flushTimeoutMs?: number;
+    readonly onError?: (key: K, error: unknown, attempt: number) => void;
+    readonly onPressure?: (pendingKeys: number) => void;
+    readonly onDiscard?: (key: K, value: V) => void;
+}
+export interface BackgroundQueueFlushResult {
+    readonly flushed: number;
+    readonly remaining: number;
+}
+export declare class BackgroundQueue<K extends string, V> {
+    private readonly writer;
+    private readonly coalesce;
+    private readonly maxPendingKeys;
+    private readonly maxWriteConcurrency;
+    private readonly flushTimeoutMs;
+    private readonly onError?;
+    private readonly onPressure?;
+    private readonly onDiscard?;
+    private readonly pendingByKey;
+    private readonly retryTimersByKey;
+    private readonly stateWaiters;
+    private drainingPromise;
+    private inFlight;
+    private flushedCount;
+    private shutdownRequested;
+    private retryDisabled;
+    constructor(writer: (key: K, value: V) => Promise<void>, options?: BackgroundQueueOptions<K, V>);
+    enqueue(key: K, value: V): void;
+    enqueueAsync(key: K, value: V): Promise<void>;
+    private waitForCapacity;
+    private addPendingEntry;
+    private detachRetryEntry;
+    flush(timeoutMs?: number): Promise<BackgroundQueueFlushResult>;
+    destroy(timeoutMs?: number): Promise<BackgroundQueueFlushResult>;
+    private ensureDrain;
+    private drainLoop;
+    private takeBatch;
+    private processEntry;
+    private takeNext;
+    private mergeForRetry;
+    private retryDelayMs;
+    private scheduleRetry;
+    private resolveEntry;
+    private discardEntry;
+    private discardPending;
+    private remaining;
+    private trackedKeys;
+    private notifyStateChange;
+    private waitForStateChange;
+    private removeStateWaiter;
+    private invokeOnError;
+    private invokeOnPressure;
+    private invokeOnDiscard;
+}

package/dist/types/infra/perf/BoundedTaskQueue.d.ts

@@ -10,10 +10,10 @@ export declare class BoundedTaskQueue {
     private head;
     private running;
     constructor(maxQueueSize?: number, maxConcurrency?: number);
+    private readonly settleTask;
     enqueue<T>(task: Task<T>): Promise<T>;
     pending(): number;
     inFlight(): number;
     private drain;
-    private compactIfNeeded;
 }
 export {};

package/dist/types/infra/perf/PromiseDedup.d.ts

@@ -0,0 +1,4 @@
+export declare class PromiseDedup {
+    private readonly inFlight;
+    run<T>(key: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/types/infra/perf/SharedExclusiveGate.d.ts

@@ -0,0 +1,17 @@
+type SharedExclusiveTask<T> = () => Promise<T>;
+export declare class SharedExclusiveGate {
+    private activeShared;
+    private pendingExclusive;
+    private exclusiveActive;
+    private closed;
+    private readonly waiters;
+    runShared<T>(task: SharedExclusiveTask<T>): Promise<T>;
+    private runSharedSlow;
+    runExclusive<T>(task: SharedExclusiveTask<T>): Promise<T>;
+    close(): Promise<void>;
+    private acquireShared;
+    private acquireExclusive;
+    private notifyStateChange;
+    private waitForStateChange;
+}
+export {};

package/dist/types/infra/perf/StoreLock.d.ts

@@ -0,0 +1,10 @@
+type StoreTask<T> = () => Promise<T>;
+export declare class StoreLock {
+    private readonly chains;
+    private closed;
+    run<T>(key: string, task: StoreTask<T>): Promise<T>;
+    private runInternal;
+    runMany<T>(keys: readonly string[], task: StoreTask<T>): Promise<T>;
+    shutdown(): Promise<void>;
+}
+export {};

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

@@ -1,12 +1,13 @@
 import type { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
+import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaFileEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
 export declare class WaMediaCrypto {
     static generateMediaKey(): Promise<Uint8Array>;
     static deriveKeys(mediaType: MediaCryptoType, mediaKey: Uint8Array): Promise<WaMediaDerivedKeys>;
     static encryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Uint8Array): Promise<WaMediaEncryptionResult>;
     static decryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, ciphertextHmac: Uint8Array, expectedFileSha256?: Uint8Array, expectedFileEncSha256?: Uint8Array): Promise<WaMediaDecryptionResult>;
     static encryptReadable(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable): Promise<WaMediaReadableEncryptionResult>;
-    static decryptReadableToBytes(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaDecryptionResult>;
+    static encryptToFile(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable): Promise<WaMediaFileEncryptionResult>;
+    static cleanupEncryptedFile(filePath: string): Promise<void>;
     static decryptReadable(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaReadableDecryptionResult>;
     static encryptedLength(plaintextLength: number): number;
 }

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

@@ -1,10 +1,12 @@
 import { Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaTransferClientOptions } from './types';
+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;
     readonly maxBytes?: number;
@@ -35,6 +37,7 @@ interface EncryptedUploadResult {
     readonly mediaKey: Uint8Array;
     readonly fileSha256: Uint8Array;
     readonly fileEncSha256: Uint8Array;
+    readonly plaintextLength: number;
 }
 interface EncryptedDownloadRequest extends StreamDownloadRequest {
     readonly mediaType: MediaCryptoType;
@@ -42,40 +45,38 @@ interface EncryptedDownloadRequest extends StreamDownloadRequest {
     readonly fileSha256?: Uint8Array;
     readonly fileEncSha256?: Uint8Array;
 }
-interface EncryptedDownloadStream {
-    readonly plaintext: Readable;
-    readonly metadata: Promise<{
-        readonly fileSha256: Uint8Array;
-        readonly fileEncSha256: Uint8Array;
-    }>;
-}
 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;
     constructor(options?: WaMediaTransferClientOptions);
     downloadStream(request: StreamDownloadRequest): Promise<StreamTransferResponse>;
     downloadBytes(request: StreamDownloadRequest): Promise<Uint8Array>;
     uploadStream(request: StreamUploadRequest): Promise<StreamTransferResponse>;
     uploadEncrypted(request: EncryptedUploadRequest): Promise<EncryptedUploadResult>;
     downloadAndDecrypt(request: EncryptedDownloadRequest): Promise<Uint8Array>;
-    downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<EncryptedDownloadStream>;
+    downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<WaMediaReadableDecryptionResult>;
     readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
+    private transferRequest;
+    private fetchWithDispatcher;
+    private toFetchTransferResponse;
+    private gotWithAgent;
+    private loadGotModule;
+    private toGotTransferResponse;
     private resolveTransferRequest;
-    private executeTransfer;
     private prepareEncryptedUpload;
     private assertSuccessfulResponse;
     private requireResponseBody;
     private resolveUrls;
-    private mergeHeaders;
-    private readAllBytesWithLimit;
     private fetchWithFallback;
     private createAbortContext;
-    private toResponse;
-    private headersToRecord;
-    private cancelWebBody;
     private drainBody;
 }
 export {};

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

@@ -7,4 +7,4 @@ export declare const ENC_KEY_END = 48;
 export declare const MAC_KEY_START = 48;
 export declare const MAC_KEY_END = 80;
 export declare const HMAC_TRUNCATED_SIZE = 10;
-export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt', string>>;
+export declare const MEDIA_UPLOAD_PATHS: Readonly<Record<'image' | 'video' | 'audio' | 'document' | 'sticker' | 'gif' | 'ptt' | 'ptv', string>>;

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

@@ -1,4 +1,4 @@
 export { WaMediaTransferClient } from './WaMediaTransferClient';
 export { parseMediaConnResponse } from './conn';
-export type { WaMediaConn, WaMediaConnHost, WaMediaTransferClientOptions, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaDecryptionResult, WaMediaReadableEncryptionResult, WaMediaReadableDecryptionResult } from './types';
+export type { WaMediaConn } from './types';
 export { WaMediaCrypto } from './WaMediaCrypto';

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

@@ -1,7 +1,8 @@
 import type { Readable } from 'node:stream';
 import type { Logger } from '../infra/log/types';
-export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker';
-export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'ptv' | 'history' | 'md-app-state';
+import type { WaProxyAgent, WaProxyDispatcher } from '../transport/types';
+export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'ptv';
+export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'history' | 'md-app-state';
 export interface WaMediaConnHost {
     readonly hostname: string;
     readonly isFallback: boolean;
@@ -17,6 +18,10 @@ 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;
 }
 export interface WaMediaDerivedKeys {
     readonly iv: Uint8Array;
@@ -39,6 +44,7 @@ export interface WaMediaReadableEncryptionResult {
     readonly metadata: Promise<{
         readonly fileSha256: Uint8Array;
         readonly fileEncSha256: Uint8Array;
+        readonly plaintextLength: number;
     }>;
 }
 export interface WaMediaReadableDecryptionResult {
@@ -48,6 +54,13 @@ export interface WaMediaReadableDecryptionResult {
         readonly fileEncSha256: Uint8Array;
     }>;
 }
+export interface WaMediaFileEncryptionResult {
+    readonly filePath: string;
+    readonly fileSize: number;
+    readonly fileSha256: Uint8Array;
+    readonly fileEncSha256: Uint8Array;
+    readonly plaintextLength: number;
+}
 export interface WaMediaDecryptReadableOptions {
     readonly mediaType: MediaCryptoType;
     readonly mediaKey: Uint8Array;

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

@@ -0,0 +1,25 @@
+import { WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret';
+type WaAddonBytes = Uint8Array | ArrayBuffer | ArrayBufferView;
+export declare function shouldUseAddonAdditionalData(modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES]): boolean;
+export declare function buildAddonAdditionalData(stanzaId: string, addOnSenderJid: string): Uint8Array;
+export declare function encryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly payload: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+export declare function decryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly ciphertext: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+export {};

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

@@ -2,3 +2,11 @@ import type { WaSendMediaMessage } from './types';
 import type { Proto } from '..';
 export declare function isSendMediaMessage(content: unknown): content is WaSendMediaMessage;
 export declare function resolveMessageTypeAttr(message: Proto.IMessage): string;
+export declare function resolveEditAttr(message: Proto.IMessage, subtype?: string): string | null;
+export declare function resolveEncMediaType(message: Proto.IMessage): string | 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/icdc.d.ts

@@ -0,0 +1,13 @@
+import type { Proto } from '..';
+import type { SignalAddress } from '../signal/types';
+import type { WaSignalStore } from '../store/contracts/signal.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?: {
+    readonly address: SignalAddress;
+    readonly pubKey: Uint8Array;
+}): Promise<IcdcMeta | null>;
+export declare function injectDeviceListMetadata(message: Proto.IMessage, senderIcdc: IcdcMeta | null, recipientIcdc: IcdcMeta | null): Proto.IMessage;

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

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

package/dist/types/message/reporting-token.d.ts

@@ -0,0 +1,18 @@
+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;
+    readonly stanzaId: string;
+    readonly senderUserJid: string;
+    readonly remoteJid: string;
+    readonly version?: number;
+}
+export interface BuildReportingTokenArtifactsResult {
+    readonly node: BinaryNode;
+    readonly version: number;
+    readonly reportingToken: Uint8Array;
+    readonly reportingTokenContent: Uint8Array;
+    readonly reportingTokenKey: Uint8Array;
+}
+export declare function buildReportingTokenArtifacts(input: BuildReportingTokenNodeInput): Promise<BuildReportingTokenArtifactsResult | null>;

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

@@ -1,4 +1,4 @@
-import type { MediaKind } from '../media/types';
+import type { Readable } from 'node:stream';
 import type { Proto } from '..';
 import type { BinaryNode } from '../transport/types';
 export interface WaMessagePublishOptions {
@@ -21,18 +21,48 @@ export interface WaMessagePublishResult {
     readonly ackNode: BinaryNode;
     readonly ack: WaMessageAckMetadata;
 }
-export interface WaSendMediaMessage {
-    readonly type: MediaKind;
-    readonly media: Uint8Array | ArrayBuffer;
+type MediaInput = Uint8Array | ArrayBuffer | Readable;
+interface WaSendMediaBase {
+    readonly media: MediaInput;
     readonly mimetype: string;
+    readonly fileLength?: number;
+}
+interface WaSendImageMessage extends WaSendMediaBase {
+    readonly type: 'image';
+    readonly caption?: string;
+    readonly width?: number;
+    readonly height?: number;
+}
+interface WaSendVideoMessage extends WaSendMediaBase {
+    readonly type: 'video';
     readonly caption?: string;
-    readonly fileName?: string;
-    readonly ptt?: boolean;
     readonly gifPlayback?: boolean;
     readonly seconds?: number;
     readonly width?: number;
     readonly height?: number;
 }
+interface WaSendPtvMessage extends WaSendMediaBase {
+    readonly type: 'ptv';
+    readonly seconds?: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+interface WaSendAudioMessage extends WaSendMediaBase {
+    readonly type: 'audio';
+    readonly ptt?: boolean;
+    readonly seconds?: number;
+}
+interface WaSendDocumentMessage extends WaSendMediaBase {
+    readonly type: 'document';
+    readonly caption?: string;
+    readonly fileName?: string;
+}
+interface WaSendStickerMessage extends WaSendMediaBase {
+    readonly type: 'sticker';
+    readonly width?: number;
+    readonly height?: number;
+}
+export type WaSendMediaMessage = WaSendImageMessage | WaSendVideoMessage | WaSendPtvMessage | WaSendAudioMessage | WaSendDocumentMessage | WaSendStickerMessage;
 export type WaSendMessageContent = string | Proto.IMessage | WaSendMediaMessage;
 export interface WaEncryptedMessageInput {
     readonly to: string;
@@ -43,16 +73,25 @@ export interface WaEncryptedMessageInput {
     readonly encCount?: number;
     readonly id?: string;
     readonly type?: string;
+    readonly edit?: string;
+    readonly mediatype?: string;
     readonly category?: string;
     readonly pushPriority?: string;
     readonly participant?: string;
     readonly deviceFanout?: string;
+    readonly metaNode?: BinaryNode;
 }
 export interface WaSendReceiptInput {
     readonly to: string;
     readonly id: string;
     readonly type?: string;
     readonly participant?: string;
+    readonly recipient?: string;
+    readonly category?: string;
     readonly from?: string;
     readonly t?: string;
+    readonly peerParticipantPn?: string;
+    readonly listIds?: readonly string[];
+    readonly content?: readonly BinaryNode[];
 }
+export {};

package/dist/types/message/use-case-secret.d.ts

@@ -0,0 +1,20 @@
+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";
+    readonly ENC_REACTION: "Enc Reaction";
+    readonly ENC_COMMENT: "Enc Comment";
+    readonly REPORT_TOKEN: "Report Token";
+    readonly EVENT_RESPONSE: "Event Response";
+    readonly EVENT_EDIT_ENCRYPTED: "Event Edit";
+    readonly MESSAGE_EDIT: "Message Edit";
+}>;
+export declare function assertMessageSecret(messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView, context?: string): Uint8Array;
+export declare function ensureMessageSecret(message: Proto.IMessage): Promise<Proto.IMessage>;
+export declare function createUseCaseSecret(input: {
+    readonly messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+}): Promise<Uint8Array>;

package/dist/types/protocol/appstate.d.ts

@@ -32,3 +32,50 @@ export declare const WA_APP_STATE_KDF_INFO: Readonly<{
     readonly MUTATION_KEYS: "WhatsApp Mutation Keys";
     readonly PATCH_INTEGRITY: "WhatsApp Patch Integrity";
 }>;
+export declare const WA_APP_STATE_CHAT_MUTATION_SPECS: Readonly<{
+    readonly STAR: {
+        readonly collection: "regular_high";
+        readonly action: "star";
+        readonly version: 2;
+    };
+    readonly MUTE: {
+        readonly collection: "regular_high";
+        readonly action: "mute";
+        readonly version: 2;
+    };
+    readonly PIN: {
+        readonly collection: "regular_low";
+        readonly action: "pin_v1";
+        readonly version: 5;
+    };
+    readonly ARCHIVE: {
+        readonly collection: "regular_low";
+        readonly action: "archive";
+        readonly version: 3;
+    };
+    readonly DELETE_MESSAGE_FOR_ME: {
+        readonly collection: "regular_high";
+        readonly action: "deleteMessageForMe";
+        readonly version: 3;
+    };
+    readonly MARK_CHAT_AS_READ: {
+        readonly collection: "regular_low";
+        readonly action: "markChatAsRead";
+        readonly version: 3;
+    };
+    readonly CLEAR_CHAT: {
+        readonly collection: "regular_high";
+        readonly action: "clearChat";
+        readonly version: 6;
+    };
+    readonly DELETE_CHAT: {
+        readonly collection: "regular_high";
+        readonly action: "deleteChat";
+        readonly version: 6;
+    };
+    readonly LOCK_CHAT: {
+        readonly collection: "regular_low";
+        readonly action: "lock";
+        readonly version: 7;
+    };
+}>;

package/dist/types/protocol/constants.d.ts

@@ -1,11 +1,16 @@
 export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser';
 export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
+export { WA_CONNECTION_REASONS, WA_DISCONNECT_REASONS, WA_FAILURE_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
+export type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason, WaFailureReasonCode, WaStreamErrorCode } from './stream';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
+export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_POLL_META_TYPES, WA_RETRYABLE_ACK_CODES, WA_STANZA_MSG_TYPES } from './message';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
+export { WA_PRIVACY_TOKEN_NOTIFICATION_TYPE, WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from './privacy-token';
+export { WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from './privacy';
+export type { WaPrivacyCategory, WaPrivacySettingName, WaPrivacyValue } from './privacy';
 export { WA_DEFAULTS } from './defaults';
 export { WA_GROUP_PARTICIPANT_TYPES, type WaGroupSetting } from './group';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';

package/dist/types/protocol/defaults.d.ts

@@ -2,6 +2,12 @@ export declare const WA_DEFAULTS: Readonly<{
     readonly HOST_DOMAIN: "s.whatsapp.net";
     readonly GROUP_SERVER: "g.us";
     readonly BROADCAST_SERVER: "broadcast";
+    readonly LID_SERVER: "lid";
+    readonly HOSTED_SERVER: "hosted";
+    readonly HOSTED_LID_SERVER: "hosted.lid";
+    readonly HOSTED_DEVICE_ID: 99;
+    readonly MSGR_SERVER: "msgr";
+    readonly INTEROP_SERVER: "interop";
     readonly DEVICE_BROWSER: "firefox";
     readonly DEVICE_PLATFORM: string;
     readonly CHAT_SOCKET_URLS: readonly ["wss://web.whatsapp.com/ws/chat", "wss://web.whatsapp.com:5222/ws/chat"];

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

@@ -1,11 +1,2 @@
-export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser';
-export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
-export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
-export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
-export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
-export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
-export { WA_DEFAULTS } from './defaults';
-export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid';
+export * from './constants';
+export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, signalAddressKey, toUserJid } from './jid';

package/dist/types/protocol/jid.d.ts

@@ -1,19 +1,36 @@
 import type { SignalAddress } from '../signal/types';
-export interface ParsedJid {
+export declare function splitJid(jid: string): {
     readonly user: string;
     readonly server: string;
-}
-export declare function splitJid(jid: string): ParsedJid;
+};
 export declare function normalizeRecipientJid(to: string): string;
-export declare function isJidType(jid: string, type: string): boolean;
 export declare function isGroupJid(jid: string): boolean;
 export declare function isBroadcastJid(jid: string): boolean;
 export declare function isGroupOrBroadcastJid(jid: string): boolean;
+export interface ParsedJid {
+    readonly address: SignalAddress;
+    readonly userJid: string;
+    readonly normalizedJid: string;
+}
 export declare function parseSignalAddressFromJid(jid: string): SignalAddress;
-export declare function toUserJid(jid: string): string;
+export declare function parseJidFull(jid: string): ParsedJid;
+export declare function canonicalizeSignalServer(server: string, hostDomain?: string): string;
+export declare function canonicalizeSignalJid(jid: string, hostDomain?: string): string;
+export declare function toUserJid(jid: string, options?: {
+    readonly canonicalizeSignalServer?: boolean;
+    readonly hostDomain?: string;
+}): string;
 export declare function normalizeDeviceJid(jid: string): string;
+export declare function isHostedDeviceId(deviceId: number): boolean;
+export declare function isHostedServer(server: string): boolean;
+export declare function isHostedDeviceJid(jid: string): boolean;
+export declare function buildDeviceJid(user: string, normalizedServer: string, deviceId: number, options?: {
+    readonly rawServer?: string;
+    readonly isHosted?: boolean;
+}): string;
 export declare function getLoginIdentity(meJid: string): {
     readonly username: number;
     readonly device: number;
 };
 export declare function parsePhoneJid(input: string): string;
+export declare function signalAddressKey(address: SignalAddress): string;