zapo-js 0.1.0

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

@@ -0,0 +1,15 @@
+export declare const WA_DIRTY_TYPES: Readonly<{
+    readonly ACCOUNT_SYNC: "account_sync";
+    readonly GROUPS: "groups";
+    readonly SYNCD_APP_STATE: "syncd_app_state";
+    readonly NEWSLETTER_METADATA: "newsletter_metadata";
+}>;
+export declare const WA_DIRTY_PROTOCOLS: Readonly<{
+    readonly DEVICES: "devices";
+    readonly PICTURE: "picture";
+    readonly PRIVACY: "privacy";
+    readonly BLOCKLIST: "blocklist";
+    readonly NOTICE: "notice";
+}>;
+export declare const WA_ACCOUNT_SYNC_PROTOCOLS: readonly ["devices", "picture", "privacy", "blocklist", "notice"];
+export declare const WA_SUPPORTED_DIRTY_TYPES: readonly ["account_sync", "syncd_app_state", "groups", "newsletter_metadata"];

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

@@ -0,0 +1,6 @@
+export declare const WA_GROUP_PARTICIPANT_TYPES: Readonly<{
+    readonly SUPERADMIN: "superadmin";
+    readonly ADMIN: "admin";
+    readonly REGULAR: "participant";
+}>;
+export type WaGroupSetting = 'announcement' | 'restrict' | 'ephemeral' | 'membership_approval_mode';

package/dist/types/protocol/index.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 { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid';

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

@@ -0,0 +1,19 @@
+import type { SignalAddress } from '../signal/types';
+export interface ParsedJid {
+    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 declare function parseSignalAddressFromJid(jid: string): SignalAddress;
+export declare function toUserJid(jid: string): string;
+export declare function normalizeDeviceJid(jid: string): string;
+export declare function getLoginIdentity(meJid: string): {
+    readonly username: number;
+    readonly device: number;
+};
+export declare function parsePhoneJid(input: string): string;

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

@@ -0,0 +1,15 @@
+export declare const WA_MEDIA_HKDF_INFO: Readonly<{
+    readonly document: "WhatsApp Document Keys";
+    readonly image: "WhatsApp Image Keys";
+    readonly sticker: "WhatsApp Image Keys";
+    readonly 'xma-image': "WhatsApp Image Keys";
+    readonly video: "WhatsApp Video Keys";
+    readonly gif: "WhatsApp Video Keys";
+    readonly audio: "WhatsApp Audio Keys";
+    readonly ptt: "WhatsApp Audio Keys";
+    readonly 'md-app-state': "WhatsApp App State Keys";
+    readonly 'md-msg-hist': "WhatsApp History Keys";
+    readonly history: "WhatsApp History Keys";
+}>;
+export declare const WA_PREVIEW_MEDIA_HKDF_INFO = "Messenger Preview Keys";
+export declare function getWaMediaHkdfInfo(mediaType: string): string;

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

@@ -0,0 +1,16 @@
+export declare const WA_MESSAGE_TAGS: Readonly<{
+    readonly MESSAGE: "message";
+    readonly ENC: "enc";
+    readonly RECEIPT: "receipt";
+    readonly ACK: "ack";
+    readonly ERROR: "error";
+}>;
+export declare const WA_MESSAGE_TYPES: Readonly<{
+    readonly ENC_VERSION: "2";
+    readonly MEDIA_NOTIFY: "medianotify";
+    readonly ACK_TYPE_ERROR: "error";
+    readonly ACK_CLASS_ERROR: "error";
+    readonly ACK_CLASS_MESSAGE: "message";
+    readonly RECEIPT_TYPE_PEER: "peer_msg";
+}>;
+export declare const WA_RETRYABLE_ACK_CODES: readonly ["408", "429", "500", "503"];

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

@@ -0,0 +1,83 @@
+export declare const WA_NODE_TAGS: Readonly<{
+    readonly IQ: "iq";
+    readonly SYNC: "sync";
+    readonly COLLECTION: "collection";
+    readonly PATCH: "patch";
+    readonly PATCHES: "patches";
+    readonly SNAPSHOT: "snapshot";
+    readonly ERROR: "error";
+    readonly ACK: "ack";
+    readonly NOTIFICATION: "notification";
+    readonly SUCCESS: "success";
+    readonly INFO_BULLETIN: "ib";
+    readonly DIRTY: "dirty";
+    readonly EDGE_ROUTING: "edge_routing";
+    readonly ROUTING_INFO: "routing_info";
+    readonly MEDIA_CONN: "media_conn";
+    readonly HOST: "host";
+    readonly USYNC: "usync";
+    readonly QUERY: "query";
+    readonly DEVICES: "devices";
+    readonly DEVICE: "device";
+    readonly DIGEST: "digest";
+    readonly KEY_FETCH: "key_fetch";
+    readonly LIST: "list";
+    readonly USER: "user";
+    readonly PICTURE: "picture";
+    readonly PRIVACY: "privacy";
+    readonly PARTICIPATING: "participating";
+    readonly PARTICIPANTS: "participants";
+    readonly DESCRIPTION: "description";
+    readonly MY_ADDONS: "my_addons";
+    readonly KEY: "key";
+    readonly REGISTRATION: "registration";
+    readonly TYPE: "type";
+    readonly IDENTITY: "identity";
+    readonly SKEY: "skey";
+    readonly ID: "id";
+    readonly REF: "ref";
+    readonly VALUE: "value";
+    readonly SIGNATURE: "signature";
+    readonly HASH: "hash";
+    readonly ROTATE: "rotate";
+    readonly PAIR_DEVICE: "pair-device";
+    readonly PAIR_SUCCESS: "pair-success";
+    readonly LINK_CODE_COMPANION_REG: "link_code_companion_reg";
+    readonly LINK_CODE_PAIRING_REF: "link_code_pairing_ref";
+    readonly COUNTRY_CODE: "country_code";
+    readonly DEVICE_IDENTITY: "device-identity";
+    readonly PLATFORM: "platform";
+    readonly SUBJECT: "subject";
+    readonly BODY: "body";
+    readonly PARTICIPANT: "participant";
+    readonly INVITE: "invite";
+    readonly LEAVE: "leave";
+    readonly GROUP: "group";
+    readonly LOCKED: "locked";
+    readonly UNLOCKED: "unlocked";
+    readonly ANNOUNCEMENT: "announcement";
+    readonly EPHEMERAL: "ephemeral";
+    readonly MEMBERSHIP_APPROVAL_MODE: "membership_approval_mode";
+    readonly GROUP_JOIN: "group_join";
+}>;
+export declare const WA_IQ_TYPES: Readonly<{
+    readonly GET: "get";
+    readonly SET: "set";
+    readonly RESULT: "result";
+    readonly ERROR: "error";
+}>;
+export declare const WA_XMLNS: Readonly<{
+    readonly MD: "md";
+    readonly APP_STATE_SYNC: "w:sync:app:state";
+    readonly MEDIA: "w:m";
+    readonly SIGNAL: "encrypt";
+    readonly DIRTY_BITS: "urn:xmpp:whatsapp:dirty";
+    readonly PROFILE_PICTURE: "w:profile:picture";
+    readonly PRIVACY: "privacy";
+    readonly BLOCKLIST: "blocklist";
+    readonly USYNC: "usync";
+    readonly GROUPS: "w:g2";
+    readonly NEWSLETTER: "newsletter";
+    readonly XMPP_PING: "urn:xmpp:ping";
+    readonly WHATSAPP_PING: "w:p";
+}>;

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

@@ -0,0 +1,50 @@
+export declare const WA_NOTIFICATION_TYPES: Readonly<{
+    readonly GROUP: "w:gp2";
+}>;
+export declare const WA_GROUP_NOTIFICATION_TAGS: Readonly<{
+    readonly REMOVE: "remove";
+    readonly ADD: "add";
+    readonly DEMOTE: "demote";
+    readonly DELETE: "delete";
+    readonly PROMOTE: "promote";
+    readonly MODIFY: "modify";
+    readonly CREATE: "create";
+    readonly SUBJECT: "subject";
+    readonly DESCRIPTION: "description";
+    readonly LOCKED: "locked";
+    readonly UNLOCKED: "unlocked";
+    readonly ANNOUNCEMENT: "announcement";
+    readonly NOT_ANNOUNCEMENT: "not_announcement";
+    readonly NO_FREQUENTLY_FORWARDED: "no_frequently_forwarded";
+    readonly FREQUENTLY_FORWARDED_OK: "frequently_forwarded_ok";
+    readonly INVITE: "invite";
+    readonly EPHEMERAL: "ephemeral";
+    readonly NOT_EPHEMERAL: "not_ephemeral";
+    readonly REVOKE: "revoke";
+    readonly SUSPENDED: "suspended";
+    readonly UNSUSPENDED: "unsuspended";
+    readonly GROWTH_LOCKED: "growth_locked";
+    readonly GROWTH_UNLOCKED: "growth_unlocked";
+    readonly LINK: "link";
+    readonly UNLINK: "unlink";
+    readonly LINKED_GROUP_PROMOTE: "linked_group_promote";
+    readonly LINKED_GROUP_DEMOTE: "linked_group_demote";
+    readonly MEMBERSHIP_APPROVAL_MODE: "membership_approval_mode";
+    readonly MEMBERSHIP_APPROVAL_REQUEST: "membership_approval_request";
+    readonly CREATED_MEMBERSHIP_REQUESTS: "created_membership_requests";
+    readonly REVOKED_MEMBERSHIP_REQUESTS: "revoked_membership_requests";
+    readonly ALLOW_NON_ADMIN_SUB_GROUP_CREATION: "allow_non_admin_sub_group_creation";
+    readonly NOT_ALLOW_NON_ADMIN_SUB_GROUP_CREATION: "not_allow_non_admin_sub_group_creation";
+    readonly ALLOW_ADMIN_REPORTS: "allow_admin_reports";
+    readonly NOT_ALLOW_ADMIN_REPORTS: "not_allow_admin_reports";
+    readonly REPORTS: "reports";
+    readonly CREATED_SUB_GROUP_SUGGESTION: "created_sub_group_suggestion";
+    readonly REVOKED_SUB_GROUP_SUGGESTIONS: "revoked_sub_group_suggestions";
+    readonly CHANGE_NUMBER: "change_number";
+    readonly MEMBER_ADD_MODE: "member_add_mode";
+    readonly AUTO_ADD_DISABLED: "auto_add_disabled";
+    readonly IS_CAPI_HOSTED_GROUP: "is_capi_hosted_group";
+    readonly GROUP_SAFETY_CHECK: "group_safety_check";
+    readonly LIMIT_SHARING_ENABLED: "limit_sharing_enabled";
+    readonly MISSING_PARTICIPANT_IDENTIFICATION: "missing_participant_identification";
+}>;

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

@@ -0,0 +1,60 @@
+export declare const WA_READY_STATES: Readonly<{
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+}>;
+export declare const WA_LOGOUT_REASONS: Readonly<{
+    readonly USER_INITIATED: "user_initiated";
+    readonly SYNCD_FAILURE: "syncd_failure";
+    readonly INVALID_ADV_STATUS: "invalid_adv_status";
+    readonly CRITICAL_SYNC_TIMEOUT: "critical_sync_timeout";
+    readonly SYNCD_TIMEOUT: "syncd_timeout";
+    readonly HISTORY_SYNC_TIMEOUT: "history_sync_timeout";
+    readonly ACCOUNT_SYNC_TIMEOUT: "account_sync_timeout";
+    readonly MD_OPT_OUT: "md_opt_out";
+    readonly UNKNOWN_COMPANION: "unknown_companion";
+    readonly CLIENT_VERSION_OUTDATED: "client_version_outdated";
+    readonly SYNCD_ERROR_DURING_BOOTSTRAP: "syncd_error_during_bootstrap";
+    readonly ACCOUNT_SYNC_ERROR: "account_sync_error";
+    readonly STORAGE_QUOTA_EXCEEDED: "storage_quota_exceeded";
+    readonly PRIMARY_IDENTITY_KEY_CHANGE: "primary_identity_key_change";
+    readonly MISSING_ENC_SALT: "missing_enc_salt";
+    readonly MISSING_SCREEN_LOCK_SALT: "missing_screen_lock_salt";
+    readonly ACCOUNT_LOCKED: "account_locked";
+    readonly LID_MIGRATION_SPLIT_THREAD_MISMATCH: "lid_migration_split_thread_mismatch";
+    readonly LID_MIGRATION_NO_LID_AVAILABLE: "lid_migration_no_lid_available";
+    readonly LID_MIGRATION_PRIMARY_MAPPINGS_OBSOLETE: "lid_migration_primary_mappings_obsolete";
+    readonly LID_MIGRATION_PEER_MAPPINGS_NOT_RECEIVED: "lid_migration_peer_mapping_not_received";
+    readonly LID_MIGRATION_STATE_DISCREPANCY: "lid_migration_state_discrepancy";
+    readonly LID_MIGRATION_PEER_MAPPINGS_MALFORMED: "lid_migration_peer_mapping_malformed";
+    readonly LID_MIGRATION_FAILED_TO_PARSE_MAPPING: "lid_migration_failed_to_parse_mapping";
+    readonly LID_MIGRATION_COMPANION_INCOMPATIBLE_KILLSWITCH: "lid_migration_companion_incompatible_killswitch";
+    readonly LID_MIGRATION_ONE_ON_ONE_THREAD_MIGRATION_INTERNAL_ERROR: "lid_migration_one_on_one_thread_migration_internal_error";
+    readonly LID_BLOCKLIST_PN_WHEN_MIGRATED: "lid_blocklist_pn_when_migrated";
+    readonly LID_BLOCKLIST_CHAT_DB_UNMIGRATED: "lid_blocklist_chat_db_unmigrated";
+    readonly WEB_FAIL_ADD_CHAT: "web_fail_add_chat";
+    readonly WEB_FAIL_OFFLINE_RESUME: "web_fail_offline_resume";
+    readonly WEB_FAIL_STORAGE_INITIALIZATION: "web_fail_storage_initialization";
+    readonly WEB_FAIL_ENC_SALT: "web_fail_enc_salt";
+    readonly CACHE_STORAGE_OPEN_FAILED: "cache_storage_open_failed";
+}>;
+export declare const WA_STREAM_SIGNALING: Readonly<{
+    readonly STREAM_ERROR_TAG: "stream:error";
+    readonly XML_STREAM_END_TAG: "xmlstreamend";
+    readonly CONFLICT_TAG: "conflict";
+    readonly ACK_TAG: "ack";
+    readonly XML_NOT_WELL_FORMED_TAG: "xml-not-well-formed";
+    readonly REPLACED_TYPE: "replaced";
+    readonly FORCE_LOGIN_CODE: 515;
+    readonly FORCE_LOGOUT_CODE: 516;
+}>;
+export declare const WA_DISCONNECT_REASONS: Readonly<{
+    readonly CLIENT_DISCONNECTED: "client_disconnected";
+    readonly COMMS_STOPPED: "comms_stopped";
+    readonly STREAM_ERROR_REPLACED: "stream_error_replaced";
+    readonly STREAM_ERROR_DEVICE_REMOVED: "stream_error_device_removed";
+    readonly STREAM_ERROR_ACK: "stream_error_ack";
+    readonly STREAM_ERROR_XML_NOT_WELL_FORMED: "stream_error_xml_not_well_formed";
+    readonly STREAM_ERROR_OTHER: "stream_error_other";
+}>;

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

@@ -0,0 +1,21 @@
+export declare const MAX_RETRY_ATTEMPTS = 5;
+export declare const RETRY_KEYS_MIN_COUNT = 2;
+export declare const RETRY_OUTBOUND_TTL_MS: number;
+export declare const RETRY_RECEIPT_VERSION = "1";
+export declare const RETRY_REASON: Readonly<{
+    readonly UnknownError: 0;
+    readonly SignalErrorNoSession: 1;
+    readonly SignalErrorInvalidKey: 2;
+    readonly SignalErrorInvalidKeyId: 3;
+    readonly SignalErrorInvalidMessage: 4;
+    readonly SignalErrorInvalidSignature: 5;
+    readonly SignalErrorFutureMessage: 6;
+    readonly SignalErrorBadMac: 7;
+    readonly SignalErrorInvalidSession: 8;
+    readonly SignalErrorInvalidMsgKey: 9;
+    readonly BadBroadcastEphemeralSetting: 10;
+    readonly UnknownCompanionNoPrekey: 11;
+    readonly AdvFailure: 12;
+    readonly StatusRevokeDelay: 13;
+}>;
+export type WaRetryReasonCode = (typeof RETRY_REASON)[keyof typeof RETRY_REASON];

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

@@ -0,0 +1,7 @@
+export { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON, RETRY_RECEIPT_VERSION } from './constants';
+export type { WaRetryReasonCode } from './constants';
+export { mapRetryReasonFromError } from './reason';
+export { parseRetryReceiptRequest } from './parse';
+export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetrySignedKey } from './types';
+export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound';
+export { WaRetryReplayService, type WaRetryReplayServiceOptions, type WaRetryResendResult } from './replay';

package/dist/types/retry/outbound.d.ts

@@ -0,0 +1,4 @@
+import type { WaRetryOutboundState, WaRetryReplayPayload } from './types';
+export declare function encodeRetryReplayPayload(payload: WaRetryReplayPayload): Uint8Array;
+export declare function decodeRetryReplayPayload(raw: Uint8Array): WaRetryReplayPayload;
+export declare function pickRetryStateMax(left: WaRetryOutboundState, right: WaRetryOutboundState): WaRetryOutboundState;

package/dist/types/retry/parse.d.ts

@@ -0,0 +1,3 @@
+import type { WaParsedRetryRequest } from './types';
+import type { BinaryNode } from '../transport/types';
+export declare function parseRetryReceiptRequest(node: BinaryNode): WaParsedRetryRequest | null;

package/dist/types/retry/reason.d.ts

@@ -0,0 +1,2 @@
+import { type WaRetryReasonCode } from './constants';
+export declare function mapRetryReasonFromError(error: unknown): WaRetryReasonCode;

package/dist/types/retry/replay.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from '../infra/log/types';
+import type { WaMessageClient } from '../message/WaMessageClient';
+import { type Proto } from '..';
+import type { WaRetryOutboundMessageRecord } from './types';
+import type { SignalProtocol } from '../signal/session/SignalProtocol';
+export interface WaRetryReplayServiceOptions {
+    readonly logger: Logger;
+    readonly messageClient: WaMessageClient;
+    readonly signalProtocol: SignalProtocol;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+}
+export type WaRetryResendResult = 'resent' | 'ineligible';
+export declare class WaRetryReplayService {
+    private readonly options;
+    constructor(options: WaRetryReplayServiceOptions);
+    resendOutboundMessage(outbound: WaRetryOutboundMessageRecord, requesterJid: string, retryCount: number): Promise<WaRetryResendResult>;
+    private resendPlaintextPayload;
+    private resendGroupPlaintextPayload;
+    private resendEncryptedPayload;
+    private resendOpaquePayload;
+    private maybeWrapGroupRetryPlaintextForSelfDevice;
+    private isRequesterCurrentAccount;
+    private get logger();
+    private get messageClient();
+    private get signalProtocol();
+    private getCurrentSignedIdentity;
+    private isOpaqueReplayCompatible;
+}

package/dist/types/retry/types.d.ts

@@ -0,0 +1,70 @@
+import type { BinaryNode } from '../transport/types';
+export type WaRetryReceiptType = 'retry' | 'enc_rekey_retry';
+export type WaRetryOutboundMode = 'plaintext' | 'encrypted' | 'opaque_node';
+export type WaRetryOutboundState = 'pending' | 'delivered' | 'read' | 'played' | 'ineligible';
+export interface WaRetryKey {
+    readonly id: number;
+    readonly publicKey: Uint8Array;
+}
+export interface WaRetrySignedKey extends WaRetryKey {
+    readonly signature: Uint8Array;
+}
+export interface WaRetryKeyBundle {
+    readonly identity: Uint8Array;
+    readonly deviceIdentity?: Uint8Array;
+    readonly key?: WaRetryKey;
+    readonly skey: WaRetrySignedKey;
+}
+export interface WaParsedRetryRequest {
+    readonly type: WaRetryReceiptType;
+    readonly stanzaId: string;
+    readonly from: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly originalMsgId: string;
+    readonly retryCount: number;
+    readonly retryReason?: number;
+    readonly t?: string;
+    readonly regId: number;
+    readonly keyBundle?: WaRetryKeyBundle;
+}
+export interface WaRetryDecryptFailureContext {
+    readonly messageNode: BinaryNode;
+    readonly stanzaId: string;
+    readonly from: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly t?: string;
+}
+export interface WaRetryPlaintextReplayPayload {
+    readonly mode: 'plaintext';
+    readonly to: string;
+    readonly type: string;
+    readonly plaintext: Uint8Array;
+}
+export interface WaRetryEncryptedReplayPayload {
+    readonly mode: 'encrypted';
+    readonly to: string;
+    readonly type: string;
+    readonly encType: 'msg' | 'pkmsg' | 'skmsg';
+    readonly ciphertext: Uint8Array;
+    readonly participant?: string;
+}
+export interface WaRetryOpaqueNodeReplayPayload {
+    readonly mode: 'opaque_node';
+    readonly node: Uint8Array;
+}
+export type WaRetryReplayPayload = WaRetryPlaintextReplayPayload | WaRetryEncryptedReplayPayload | WaRetryOpaqueNodeReplayPayload;
+export interface WaRetryOutboundMessageRecord {
+    readonly messageId: string;
+    readonly toJid: string;
+    readonly participantJid?: string;
+    readonly recipientJid?: string;
+    readonly messageType: string;
+    readonly replayMode: WaRetryOutboundMode;
+    readonly replayPayload: Uint8Array;
+    readonly state: WaRetryOutboundState;
+    readonly createdAtMs: number;
+    readonly updatedAtMs: number;
+    readonly expiresAtMs: number;
+}

package/dist/types/signal/api/SignalDeviceSyncApi.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
+import type { BinaryNode } from '../../transport/types';
+interface SignalDeviceSyncApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly deviceListStore?: WaDeviceListStore;
+    readonly defaultTimeoutMs?: number;
+    readonly hostDomain?: string;
+}
+export declare class SignalDeviceSyncApi {
+    private readonly logger;
+    private readonly query;
+    private readonly deviceListStore?;
+    private readonly defaultTimeoutMs;
+    private readonly hostDomain;
+    constructor(options: SignalDeviceSyncApiOptions);
+    syncDeviceList(userJids: readonly string[], timeoutMs?: number): Promise<readonly {
+        readonly jid: string;
+        readonly deviceJids: readonly string[];
+    }[]>;
+    private collectUsersToQuery;
+    private makeDeviceSyncRequest;
+    private parseDeviceSyncResponse;
+    private parseUserDeviceJids;
+    private normalizeUsers;
+    private normalizeUserJid;
+    private toDeviceJid;
+    private makeSid;
+}
+export {};

package/dist/types/signal/api/SignalDigestSyncApi.d.ts

@@ -0,0 +1,27 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { BinaryNode } from '../../transport/types';
+interface SignalDigestSyncApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly signalStore: WaSignalStore;
+    readonly defaultTimeoutMs?: number;
+    readonly hostDomain?: string;
+}
+export interface SignalDigestValidationResult {
+    readonly valid: boolean;
+    readonly shouldReupload: boolean;
+    readonly reason: 'ok' | 'missing_remote_digest' | 'unsupported_key_bundle_type' | 'missing_local_state' | 'registration_mismatch' | 'identity_mismatch' | 'signed_prekey_mismatch' | 'missing_local_prekey' | 'hash_mismatch';
+    readonly preKeyCount: number;
+}
+export declare class SignalDigestSyncApi {
+    private readonly logger;
+    private readonly query;
+    private readonly signalStore;
+    private readonly defaultTimeoutMs;
+    private readonly hostDomain;
+    constructor(options: SignalDigestSyncApiOptions);
+    validateLocalKeyBundle(timeoutMs?: number): Promise<SignalDigestValidationResult>;
+    private parseDigestPayload;
+}
+export {};

package/dist/types/signal/api/SignalIdentitySyncApi.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { BinaryNode } from '../../transport/types';
+export interface SignalIdentitySyncEntry {
+    readonly jid: string;
+    readonly identity: Uint8Array;
+    readonly type?: number;
+}
+interface SignalIdentitySyncApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly signalStore?: WaSignalStore;
+    readonly defaultTimeoutMs?: number;
+    readonly hostDomain?: string;
+}
+export declare class SignalIdentitySyncApi {
+    private readonly logger;
+    private readonly query;
+    private readonly signalStore?;
+    private readonly defaultTimeoutMs;
+    private readonly hostDomain;
+    constructor(options: SignalIdentitySyncApiOptions);
+    syncIdentityKeys(targetJids: readonly string[], timeoutMs?: number): Promise<readonly SignalIdentitySyncEntry[]>;
+    private parseIdentitySyncResponse;
+}
+export {};

package/dist/types/signal/api/SignalMissingPreKeysSyncApi.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalPreKeyBundle } from '../types';
+import type { BinaryNode } from '../../transport/types';
+interface SignalMissingPreKeysSyncApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly defaultTimeoutMs?: number;
+}
+export interface SignalMissingPreKeysTarget {
+    readonly userJid: string;
+    readonly reasonIdentity?: boolean;
+    readonly devices: readonly {
+        readonly deviceId: number;
+        readonly registrationId: number;
+    }[];
+}
+export interface SignalMissingPreKeysDeviceBundle {
+    readonly deviceJid: string;
+    readonly bundle: SignalPreKeyBundle;
+    readonly deviceIdentity?: Uint8Array;
+}
+export type SignalMissingPreKeysUserResult = {
+    readonly userJid: string;
+    readonly devices: readonly SignalMissingPreKeysDeviceBundle[];
+} | {
+    readonly userJid: string;
+    readonly errorCode?: number;
+    readonly errorText: string;
+};
+export declare class SignalMissingPreKeysSyncApi {
+    private readonly logger;
+    private readonly query;
+    private readonly defaultTimeoutMs;
+    constructor(options: SignalMissingPreKeysSyncApiOptions);
+    fetchMissingPreKeys(targets: readonly SignalMissingPreKeysTarget[], timeoutMs?: number): Promise<readonly SignalMissingPreKeysUserResult[]>;
+    private parseFetchMissingPreKeysResponse;
+    private parseUserDevices;
+}
+export {};

package/dist/types/signal/api/SignalRotateKeyApi.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { BinaryNode } from '../../transport/types';
+interface SignalRotateKeyApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly signalStore: WaSignalStore;
+    readonly defaultTimeoutMs?: number;
+}
+export interface SignalRotateKeyResult {
+    readonly shouldDigestKey: boolean;
+    readonly errorCode?: number;
+}
+export declare class SignalRotateKeyApi {
+    private readonly logger;
+    private readonly query;
+    private readonly signalStore;
+    private readonly defaultTimeoutMs;
+    constructor(options: SignalRotateKeyApiOptions);
+    rotateSignedPreKey(timeoutMs?: number): Promise<SignalRotateKeyResult>;
+}
+export {};

package/dist/types/signal/api/SignalSessionSyncApi.d.ts

@@ -0,0 +1,38 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalPreKeyBundle } from '../types';
+import type { BinaryNode } from '../../transport/types';
+interface SignalSessionSyncApiOptions {
+    readonly logger: Logger;
+    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly defaultTimeoutMs?: number;
+    readonly hostDomain?: string;
+}
+interface SignalSessionSyncTarget {
+    readonly jid: string;
+    readonly reasonIdentity?: boolean;
+}
+export type SignalSessionKeyBundleResult = {
+    readonly jid: string;
+    readonly bundle: SignalPreKeyBundle;
+    readonly deviceIdentity?: Uint8Array;
+} | {
+    readonly jid: string;
+    readonly errorCode?: string;
+    readonly errorText: string;
+};
+export declare class SignalSessionSyncApi {
+    private readonly logger;
+    private readonly query;
+    private readonly defaultTimeoutMs;
+    private readonly hostDomain;
+    constructor(options: SignalSessionSyncApiOptions);
+    fetchKeyBundle(target: SignalSessionSyncTarget, timeoutMs?: number): Promise<{
+        readonly jid: string;
+        readonly bundle: SignalPreKeyBundle;
+        readonly deviceIdentity?: Uint8Array;
+    }>;
+    fetchKeyBundles(targets: readonly SignalSessionSyncTarget[], timeoutMs?: number): Promise<readonly SignalSessionKeyBundleResult[]>;
+    private parseFetchKeyBundleResponse;
+    private parseUserKeyBundle;
+}
+export {};

package/dist/types/signal/api/codec.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryNode } from '../../transport/types';
+export declare function decodeExactLength(value: BinaryNode['content'], field: string, expectedLength: number): Uint8Array;
+export declare function parseUint(bytes: Uint8Array, field: string): number;

package/dist/types/signal/api/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const SIGNAL_UPLOAD_PREKEYS_COUNT = 812;
+export declare const SIGNAL_SIGNED_PREKEY_ROTATION_INTERVAL_MS: number;
+export declare const SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS: number;
+export declare const SIGNAL_KEY_BUNDLE_TYPE_BYTES: Uint8Array<ArrayBuffer>;
+export declare const SIGNAL_KEY_BUNDLE_TYPE_LENGTH = 1;
+export declare const SIGNAL_REGISTRATION_ID_LENGTH = 4;
+export declare const SIGNAL_KEY_ID_LENGTH = 3;
+export declare const SIGNAL_KEY_DATA_LENGTH = 32;
+export declare const SIGNAL_SIGNATURE_LENGTH = 64;

package/dist/types/signal/api/prekeys.d.ts

@@ -0,0 +1,6 @@
+import type { BinaryNode } from '../../transport/types';
+export { buildMissingPreKeysFetchIq, buildPreKeyUploadIq, buildSignedPreKeyRotateIq } from '../../transport/node/builders/prekeys';
+export declare function parsePreKeyUploadFailure(node: BinaryNode): {
+    readonly errorCode?: number;
+    readonly errorText: string;
+};