zapo-js 0.1.0

package/dist/types/crypto/core/primitives.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Low-level crypto primitives using WebCrypto API
+ */
+import { webcrypto } from 'node:crypto';
+/**
+ * Re-exported CryptoKey type so consumers don't need to import from 'node:crypto'
+ */
+export type CryptoKey = webcrypto.CryptoKey;
+export declare function sha256(value: Uint8Array): Promise<Uint8Array>;
+export declare function sha1(value: Uint8Array): Promise<Uint8Array>;
+export declare function sha512(value: Uint8Array): Promise<Uint8Array>;
+export declare function md5Bytes(input: string): Uint8Array;
+export declare function importAesGcmKey(raw: Uint8Array, usages: ('encrypt' | 'decrypt')[]): Promise<webcrypto.CryptoKey>;
+export declare function aesGcmEncrypt(key: webcrypto.CryptoKey, nonce: Uint8Array, plaintext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
+export declare function aesGcmDecrypt(key: webcrypto.CryptoKey, nonce: Uint8Array, ciphertext: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
+export declare function importAesCbcKey(keyBytes: Uint8Array): Promise<webcrypto.CryptoKey>;
+export declare function aesCbcEncrypt(key: webcrypto.CryptoKey, iv: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
+export declare function aesCbcDecrypt(key: webcrypto.CryptoKey, iv: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+export declare function importHmacKey(keyBytes: Uint8Array): Promise<webcrypto.CryptoKey>;
+export declare function importHmacSha512Key(keyBytes: Uint8Array): Promise<webcrypto.CryptoKey>;
+export declare function hmacSign(key: webcrypto.CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+export declare function pbkdf2DeriveAesCtrKey(password: Uint8Array, salt: Uint8Array, iterations: number): Promise<CryptoKey>;
+export declare function aesCtrEncrypt(key: CryptoKey, counter: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
+export declare function aesCtrDecrypt(key: CryptoKey, counter: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+export declare function ed25519VerifyRaw(publicKey: Uint8Array, signature: Uint8Array, message: Uint8Array): Promise<boolean>;

package/dist/types/crypto/core/random.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates cryptographically secure random bytes
+ */
+export declare function randomBytesAsync(size: number): Promise<Uint8Array>;
+/**
+ * Generates a cryptographically secure random integer in the range [min, max)
+ */
+export declare function randomIntAsync(min: number, max: number): Promise<number>;

package/dist/types/crypto/curves/Ed25519.d.ts

@@ -0,0 +1,7 @@
+import { type SignalKeyPair } from '../curves/types';
+export declare class Ed25519 {
+    static generateKeyPair(): Promise<SignalKeyPair>;
+    static keyPairFromPrivateKey(privKey: Uint8Array): Promise<SignalKeyPair>;
+    static sign(message: Uint8Array, privKey: Uint8Array): Promise<Uint8Array>;
+    static verify(message: Uint8Array, signature: Uint8Array, pubKey: Uint8Array): Promise<boolean>;
+}

package/dist/types/crypto/curves/X25519.d.ts

@@ -0,0 +1,8 @@
+import { type SignalKeyPair } from '../curves/types';
+export declare function clampCurvePrivateKeyInPlace(privateKey: Uint8Array): Uint8Array;
+export declare function montgomeryToEdwardsPublic(curvePublicKey: Uint8Array, signBit: number): Uint8Array;
+export declare class X25519 {
+    static generateKeyPair(): Promise<SignalKeyPair>;
+    static keyPairFromPrivateKey(privKey: Uint8Array): Promise<SignalKeyPair>;
+    static scalarMult(privKey: Uint8Array, pubKey: Uint8Array): Promise<Uint8Array>;
+}

package/dist/types/crypto/curves/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const X25519_PKCS8_PREFIX: Uint8Array<ArrayBufferLike>;
+export declare const ED25519_PKCS8_PREFIX: Uint8Array<ArrayBufferLike>;

package/dist/types/crypto/curves/types.d.ts

@@ -0,0 +1,10 @@
+import type { webcrypto } from 'node:crypto';
+export interface SignalKeyPair {
+    readonly pubKey: Uint8Array;
+    readonly privKey: Uint8Array;
+}
+export interface SubtleKeyPair {
+    readonly privateKey: webcrypto.CryptoKey;
+    readonly publicKey: webcrypto.CryptoKey;
+}
+export declare function pkcs8FromRawPrivate(prefix: Uint8Array, raw: Uint8Array): Uint8Array;

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

@@ -0,0 +1,3 @@
+export * from './core';
+export { Ed25519 } from './curves/Ed25519';
+export { X25519 } from './curves/X25519';

package/dist/types/crypto/math/constants.d.ts

@@ -0,0 +1,7 @@
+import type { ExtendedPoint } from '../math/types';
+export declare const FIELD_P: bigint;
+export declare const GROUP_L: bigint;
+export declare const EDWARDS_D: bigint;
+export declare const TWO_D: bigint;
+export declare const BASE_POINT: ExtendedPoint;
+export declare const IDENTITY_POINT: ExtendedPoint;

package/dist/types/crypto/math/edwards.d.ts

@@ -0,0 +1,3 @@
+import type { ExtendedPoint } from '../math/types';
+export declare function scalarMultBase(scalar: bigint): ExtendedPoint;
+export declare function encodeExtendedPoint(point: ExtendedPoint): Uint8Array;

package/dist/types/crypto/math/le.d.ts

@@ -0,0 +1,2 @@
+export declare function bytesToBigIntLE(bytes: Uint8Array): bigint;
+export declare function bigIntToBytesLE(value: bigint, length: number): Uint8Array;

package/dist/types/crypto/math/mod.d.ts

@@ -0,0 +1,5 @@
+import { FIELD_P, GROUP_L } from '../math/constants';
+export { FIELD_P, GROUP_L };
+export declare function mod(value: bigint, modulus?: bigint): bigint;
+export declare function modGroup(value: bigint): bigint;
+export declare function modInv(value: bigint, modulus?: bigint): bigint;

package/dist/types/crypto/math/types.d.ts

@@ -0,0 +1,6 @@
+export interface ExtendedPoint {
+    readonly x: bigint;
+    readonly y: bigint;
+    readonly z: bigint;
+    readonly t: bigint;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export { WaClient } from '@client';
+export type { WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from '@client';
+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 { proto } from '.';

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

@@ -0,0 +1,11 @@
+import type { LogLevel, Logger } from '../log/types';
+export declare class ConsoleLogger implements Logger {
+    readonly level: LogLevel;
+    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;
+}

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

@@ -0,0 +1,30 @@
+import type { LogLevel, Logger } from '../log/types';
+type PinoLikeLogger = {
+    level: string;
+    trace: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export interface PinoLoggerOptions {
+    readonly level?: LogLevel;
+    readonly name?: string;
+    readonly base?: Readonly<Record<string, unknown>> | null;
+    readonly pinoOptions?: Readonly<Record<string, unknown>>;
+    readonly pretty?: boolean;
+    readonly prettyOptions?: Readonly<Record<string, unknown>>;
+}
+export declare class PinoLogger implements Logger {
+    readonly level: LogLevel;
+    private readonly logger;
+    constructor(logger: PinoLikeLogger, level?: LogLevel);
+    trace(message: string, context?: Readonly<Record<string, unknown>>): void;
+    debug(message: string, context?: Readonly<Record<string, unknown>>): void;
+    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;
+}
+export declare function createPinoLogger(options?: PinoLoggerOptions): Promise<PinoLogger>;
+export {};

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

@@ -0,0 +1,9 @@
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    readonly level: LogLevel;
+    trace(message: string, context?: Readonly<Record<string, unknown>>): void;
+    debug(message: string, context?: Readonly<Record<string, unknown>>): void;
+    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;
+}

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

@@ -0,0 +1,19 @@
+type Task<T> = () => Promise<T>;
+export declare class BoundedTaskQueueFullError extends Error {
+    readonly code = "BOUNDED_TASK_QUEUE_FULL";
+    constructor(message?: string);
+}
+export declare class BoundedTaskQueue {
+    private readonly maxQueueSize;
+    private readonly maxConcurrency;
+    private readonly queue;
+    private head;
+    private running;
+    constructor(maxQueueSize?: number, maxConcurrency?: number);
+    enqueue<T>(task: Task<T>): Promise<T>;
+    pending(): number;
+    inFlight(): number;
+    private drain;
+    private compactIfNeeded;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import type { Readable } from 'node:stream';
+import type { MediaCryptoType, WaMediaDecryptReadableOptions, WaMediaDecryptionResult, WaMediaDerivedKeys, WaMediaEncryptionResult, 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 decryptReadable(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaReadableDecryptionResult>;
+    static encryptedLength(plaintextLength: number): number;
+}

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

@@ -0,0 +1,81 @@
+import { Readable } from 'node:stream';
+import type { MediaCryptoType, WaMediaTransferClientOptions } from './types';
+interface StreamDownloadRequest {
+    readonly url?: string;
+    readonly directPath?: string;
+    readonly hosts?: readonly string[];
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly maxBytes?: number;
+}
+interface StreamUploadRequest extends StreamDownloadRequest {
+    readonly method?: 'POST' | 'PUT';
+    readonly body: Uint8Array | Readable;
+    readonly contentLength?: number;
+    readonly contentType?: string;
+}
+interface StreamTransferResponse {
+    readonly url: string;
+    readonly status: number;
+    readonly ok: boolean;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: Readable | null;
+}
+interface EncryptedUploadRequest extends StreamDownloadRequest {
+    readonly mediaType: MediaCryptoType;
+    readonly method?: 'POST' | 'PUT';
+    readonly plaintext: Uint8Array | Readable;
+    readonly mediaKey?: Uint8Array;
+    readonly contentLength?: number;
+    readonly contentType?: string;
+}
+interface EncryptedUploadResult {
+    readonly transfer: StreamTransferResponse;
+    readonly mediaKey: Uint8Array;
+    readonly fileSha256: Uint8Array;
+    readonly fileEncSha256: Uint8Array;
+}
+interface EncryptedDownloadRequest extends StreamDownloadRequest {
+    readonly mediaType: MediaCryptoType;
+    readonly mediaKey: Uint8Array;
+    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;
+    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>;
+    readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
+    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/conn.d.ts

@@ -0,0 +1,3 @@
+import type { WaMediaConn } from './types';
+import type { BinaryNode } from '../transport/types';
+export declare function parseMediaConnResponse(node: BinaryNode, nowMs: number): WaMediaConn;

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

@@ -0,0 +1,10 @@
+export declare const DEFAULT_MEDIA_HOSTS: readonly ["mmg.whatsapp.net", "mmg-fallback.whatsapp.net"];
+export declare const MEDIA_CONN_CACHE_GRACE_MS = 30000;
+export declare const MEDIA_HKDF_SIZE = 112;
+export declare const IV_SIZE = 16;
+export declare const ENC_KEY_START = 16;
+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>>;

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

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

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

@@ -0,0 +1,56 @@
+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';
+export interface WaMediaConnHost {
+    readonly hostname: string;
+    readonly isFallback: boolean;
+}
+export interface WaMediaConn {
+    readonly auth: string;
+    readonly expiresAtMs: number;
+    readonly hosts: readonly WaMediaConnHost[];
+}
+export interface WaMediaTransferClientOptions {
+    readonly logger?: Logger;
+    readonly defaultHosts?: readonly string[];
+    readonly defaultTimeoutMs?: number;
+    readonly defaultMaxReadBytes?: number;
+    readonly defaultHeaders?: Readonly<Record<string, string>>;
+}
+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;
+}
+export interface WaMediaDecryptionResult {
+    readonly plaintext: Uint8Array;
+    readonly fileSha256: Uint8Array;
+    readonly fileEncSha256: Uint8Array;
+}
+export interface WaMediaReadableEncryptionResult {
+    readonly encrypted: Readable;
+    readonly metadata: Promise<{
+        readonly fileSha256: Uint8Array;
+        readonly fileEncSha256: Uint8Array;
+    }>;
+}
+export interface WaMediaReadableDecryptionResult {
+    readonly plaintext: Readable;
+    readonly metadata: Promise<{
+        readonly fileSha256: Uint8Array;
+        readonly fileEncSha256: Uint8Array;
+    }>;
+}
+export interface WaMediaDecryptReadableOptions {
+    readonly mediaType: MediaCryptoType;
+    readonly mediaKey: Uint8Array;
+    readonly expectedFileSha256?: Uint8Array;
+    readonly expectedFileEncSha256?: Uint8Array;
+}

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

@@ -0,0 +1,29 @@
+import type { Logger } from '../infra/log/types';
+import type { WaEncryptedMessageInput, WaMessagePublishOptions, WaMessagePublishResult, WaSendReceiptInput } from './types';
+import type { BinaryNode } from '../transport/types';
+interface WaMessageClientOptions {
+    readonly logger: Logger;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly defaultAckTimeoutMs?: number;
+    readonly defaultMaxAttempts?: number;
+    readonly defaultRetryDelayMs?: number;
+}
+export declare class WaMessageClient {
+    private readonly logger;
+    private readonly sendNode;
+    private readonly query;
+    private readonly defaultAckTimeoutMs;
+    private readonly defaultMaxAttempts;
+    private readonly defaultRetryDelayMs;
+    constructor(options: WaMessageClientOptions);
+    publishNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    publishEncrypted(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    sendMessageNode(node: BinaryNode): Promise<void>;
+    sendEncrypted(input: WaEncryptedMessageInput): Promise<void>;
+    private buildEncryptedMessageNode;
+    sendReceipt(input: WaSendReceiptInput): Promise<void>;
+    private isRetryablePublishError;
+    private extractAckMetadata;
+}
+export {};

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

@@ -0,0 +1,5 @@
+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;
+export declare function describeAckNode(node: BinaryNode): string;

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

@@ -0,0 +1,4 @@
+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;

package/dist/types/message/device-sent.d.ts

@@ -0,0 +1,3 @@
+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/incoming.d.ts

@@ -0,0 +1,18 @@
+import type { WaIncomingMessageEvent, WaIncomingUnhandledStanzaEvent } from '../client/types';
+import type { Logger } from '../infra/log/types';
+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 emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
+}
+export declare function handleIncomingMessageAck(node: BinaryNode, options: WaIncomingMessageAckHandlerOptions): Promise<boolean>;
+export {};

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

@@ -0,0 +1,2 @@
+export { WaMessageClient } from './WaMessageClient';
+export * from './types';

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

@@ -0,0 +1,2 @@
+export declare function writeRandomPadMax16(message: Uint8Array): Promise<Uint8Array>;
+export declare function unpadPkcs7(bytes: Uint8Array): Uint8Array;

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

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

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

@@ -0,0 +1,58 @@
+import type { MediaKind } from '../media/types';
+import type { Proto } from '..';
+import type { BinaryNode } from '../transport/types';
+export interface WaMessagePublishOptions {
+    readonly ackTimeoutMs?: number;
+    readonly maxAttempts?: number;
+    readonly retryDelayMs?: number;
+}
+export interface WaMessageAckMetadata {
+    readonly t?: string;
+    readonly sync?: string;
+    readonly phash?: string;
+    readonly refreshLid: boolean;
+    readonly addressingMode?: 'pn' | 'lid';
+    readonly count?: number;
+    readonly error?: number;
+}
+export interface WaMessagePublishResult {
+    readonly id: string;
+    readonly attempts: number;
+    readonly ackNode: BinaryNode;
+    readonly ack: WaMessageAckMetadata;
+}
+export interface WaSendMediaMessage {
+    readonly type: MediaKind;
+    readonly media: Uint8Array | ArrayBuffer;
+    readonly mimetype: string;
+    readonly caption?: string;
+    readonly fileName?: string;
+    readonly ptt?: boolean;
+    readonly gifPlayback?: boolean;
+    readonly seconds?: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+export type WaSendMessageContent = string | Proto.IMessage | WaSendMediaMessage;
+export interface WaEncryptedMessageInput {
+    readonly to: string;
+    readonly encType: 'msg' | 'pkmsg' | 'skmsg';
+    readonly ciphertext: Uint8Array;
+    readonly deviceIdentity?: Uint8Array;
+    readonly addressingMode?: 'pn' | 'lid';
+    readonly encCount?: number;
+    readonly id?: string;
+    readonly type?: string;
+    readonly category?: string;
+    readonly pushPriority?: string;
+    readonly participant?: string;
+    readonly deviceFanout?: string;
+}
+export interface WaSendReceiptInput {
+    readonly to: string;
+    readonly id: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly from?: string;
+    readonly t?: string;
+}

package/dist/types/proto.d.ts

@@ -0,0 +1,2 @@
+export { waproto as proto } from '../proto';
+export type { waproto as Proto } from '../proto';

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

@@ -0,0 +1,34 @@
+export declare const WA_APP_STATE_COLLECTIONS: Readonly<{
+    readonly REGULAR: "regular";
+    readonly REGULAR_LOW: "regular_low";
+    readonly REGULAR_HIGH: "regular_high";
+    readonly CRITICAL_BLOCK: "critical_block";
+    readonly CRITICAL_UNBLOCK_LOW: "critical_unblock_low";
+}>;
+export declare const WA_APP_STATE_COLLECTION_STATES: Readonly<{
+    readonly SUCCESS: "success";
+    readonly SUCCESS_HAS_MORE: "success_has_more";
+    readonly CONFLICT: "conflict";
+    readonly CONFLICT_HAS_MORE: "conflict_has_more";
+    readonly ERROR_RETRY: "error_retry";
+    readonly ERROR_FATAL: "error_fatal";
+    readonly BLOCKED: "blocked";
+}>;
+export declare const WA_APP_STATE_ERROR_CODES: Readonly<{
+    readonly CONFLICT: "409";
+    readonly BAD_REQUEST: "400";
+    readonly NOT_FOUND: "404";
+}>;
+export declare const WA_APP_STATE_SYNC_DATA_TYPE: Readonly<{
+    readonly PATCH: "Patch";
+    readonly SNAPSHOT: "Snapshot";
+    readonly LOCAL: "Local";
+}>;
+export declare const WA_APP_STATE_KEY_TYPES: Readonly<{
+    readonly MD_APP_STATE: "md-app-state";
+    readonly MD_MSG_HIST: "md-msg-hist";
+}>;
+export declare const WA_APP_STATE_KDF_INFO: Readonly<{
+    readonly MUTATION_KEYS: "WhatsApp Mutation Keys";
+    readonly PATCH_INTEGRITY: "WhatsApp Patch Integrity";
+}>;

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

@@ -0,0 +1,12 @@
+export declare const WA_SIGNALING: Readonly<{
+    readonly LINK_CODE_STAGE_COMPANION_HELLO: "companion_hello";
+    readonly LINK_CODE_STAGE_GET_COUNTRY_CODE: "get_country_code";
+    readonly LINK_CODE_STAGE_COMPANION_FINISH: "companion_finish";
+    readonly LINK_CODE_STAGE_REFRESH_CODE: "refresh_code";
+    readonly LINK_CODE_STAGE_PRIMARY_HELLO: "primary_hello";
+    readonly COMPANION_REG_REFRESH_NOTIFICATION: "companion_reg_refresh";
+}>;
+export declare const WA_PAIRING_KDF_INFO: Readonly<{
+    readonly LINK_CODE_BUNDLE: "link_code_pairing_key_bundle_encryption_key";
+    readonly ADV_SECRET: "adv_secret";
+}>;

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

@@ -0,0 +1,22 @@
+export declare const WA_BROWSERS: Readonly<{
+    readonly CHROME: "chrome";
+    readonly CHROMIUM: "chromium";
+    readonly FIREFOX: "firefox";
+    readonly SAFARI: "safari";
+    readonly IE: "ie";
+    readonly OPERA: "opera";
+    readonly EDGE: "edge";
+}>;
+export declare const WA_COMPANION_PLATFORM_IDS: Readonly<{
+    readonly UNKNOWN: "0";
+    readonly CHROME: "1";
+    readonly EDGE: "2";
+    readonly FIREFOX: "3";
+    readonly IE: "4";
+    readonly OPERA: "5";
+    readonly SAFARI: "6";
+    readonly ELECTRON: "7";
+    readonly UWP: "8";
+    readonly OTHER_WEB_CLIENT: "9";
+}>;
+export declare function getWaCompanionPlatformId(browser: string): string;

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

@@ -0,0 +1,11 @@
+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 { WA_GROUP_PARTICIPANT_TYPES, type WaGroupSetting } from './group';

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

@@ -0,0 +1,26 @@
+export declare const WA_DEFAULTS: Readonly<{
+    readonly HOST_DOMAIN: "s.whatsapp.net";
+    readonly GROUP_SERVER: "g.us";
+    readonly BROADCAST_SERVER: "broadcast";
+    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"];
+    readonly NOISE_RESUME_FAILURES_BEFORE_FULL_HANDSHAKE: 1;
+    readonly IQ_TIMEOUT_MS: 15000;
+    readonly NODE_QUERY_TIMEOUT_MS: 15000;
+    readonly CONNECT_TIMEOUT_MS: 10000;
+    readonly SOCKET_TIMEOUT_MS: 10000;
+    readonly RECONNECT_INTERVAL_MS: 2000;
+    readonly HEALTH_CHECK_INTERVAL_MS: 15000;
+    readonly DEAD_SOCKET_TIMEOUT_MS: 20000;
+    readonly MEDIA_TIMEOUT_MS: 30000;
+    readonly APP_STATE_SYNC_TIMEOUT_MS: 30000;
+    readonly SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS: 20000;
+    readonly MESSAGE_ACK_TIMEOUT_MS: 10000;
+    readonly MESSAGE_MAX_ATTEMPTS: 3;
+    readonly MESSAGE_RETRY_DELAY_MS: 750;
+    readonly PAIRING_CODE_MAX_AGE_SECONDS: 180;
+    readonly QR_INITIAL_TTL_MS: 60000;
+    readonly QR_ROTATION_TTL_MS: 20000;
+    readonly MAX_DANGLING_RECEIPTS: 2048;
+}>;