zapo-js 0.1.2 → 0.2.0

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

@@ -1,22 +1,16 @@
-export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteTableName, WaSqliteTableNameOverrides, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
-export { WaAuthSqliteStore } from './providers/sqlite/auth.store';
-export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store';
+export type { WaCreateStoreOptions, WaStore, WaStoreBackend, WaCacheDomain, WaStoreDomain, WaStoreMemoryLimitSelection, WaStoreSession } from './types';
 export { createStore } from './createStore';
 export type { WaAuthStore } from './contracts/auth.store';
 export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
 export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device-list.store';
 export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
 export type { WaParticipantsSnapshot, WaParticipantsStore } from './contracts/participants.store';
-export type { WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
 export type { WaSenderKeyStore } from './contracts/sender-key.store';
-export type { WaSignalStore } from './contracts/signal.store';
+export type { WaSignalMetaSnapshot, WaSignalStore } from './contracts/signal.store';
 export type { WaRetryStore } from './contracts/retry.store';
 export type { WaStoredThreadRecord, WaThreadStore } from './contracts/thread.store';
-export { WaSignalSqliteStore } from './providers/sqlite/signal.store';
-export { SenderKeySqliteStore } from './providers/sqlite/sender-key.store';
-export { WaRetrySqliteStore } from './providers/sqlite/retry.store';
-export { WaParticipantsSqliteStore } from './providers/sqlite/participants.store';
-export { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store';
+export type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from './contracts/privacy-token.store';
 export { WaAppStateMemoryStore } from './providers/memory/appstate.store';
 export { WaSignalMemoryStore } from './providers/memory/signal.store';
 export { SenderKeyMemoryStore } from './providers/memory/sender-key.store';
@@ -26,6 +20,4 @@ export { WaDeviceListMemoryStore } from './providers/memory/device-list.store';
 export { WaContactMemoryStore } from './providers/memory/contact.store';
 export { WaMessageMemoryStore } from './providers/memory/message.store';
 export { WaThreadMemoryStore } from './providers/memory/thread.store';
-export { WaContactSqliteStore } from './providers/sqlite/contact.store';
-export { WaMessageSqliteStore } from './providers/sqlite/message.store';
-export { WaThreadSqliteStore } from './providers/sqlite/thread.store';
+export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store';

package/dist/types/store/locks/appstate.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaAppStateStore } from '../contracts/appstate.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAppStateLock(store: WaAppStateStore): WithDestroyLifecycle<WaAppStateStore>;

package/dist/types/store/locks/auth.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaAuthStore } from '../contracts/auth.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAuthLock(store: WaAuthStore): WithDestroyLifecycle<WaAuthStore>;

package/dist/types/store/locks/contact.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaContactStore } from '../contracts/contact.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withContactLock(store: WaContactStore): WithDestroyLifecycle<WaContactStore>;

package/dist/types/store/locks/device-list.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaDeviceListStore } from '../contracts/device-list.store';
+export declare function withDeviceListLock(store: WaDeviceListStore): WaDeviceListStore;

package/dist/types/store/locks/message.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaMessageStore } from '../contracts/message.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withMessageLock(store: WaMessageStore): WithDestroyLifecycle<WaMessageStore>;

package/dist/types/store/locks/participants.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaParticipantsStore } from '../contracts/participants.store';
+export declare function withParticipantsLock(store: WaParticipantsStore): WaParticipantsStore;

package/dist/types/store/locks/privacy-token.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaPrivacyTokenStore } from '../contracts/privacy-token.store';
+export declare function withPrivacyTokenLock(store: WaPrivacyTokenStore): WaPrivacyTokenStore;

package/dist/types/store/locks/retry.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaRetryStore } from '../contracts/retry.store';
+export declare function withRetryLock(store: WaRetryStore): WaRetryStore;

package/dist/types/store/locks/sender-key.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSenderKeyStore } from '../contracts/sender-key.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSenderKeyLock(store: WaSenderKeyStore): WithDestroyLifecycle<WaSenderKeyStore>;

package/dist/types/store/locks/signal.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSignalStore } from '../contracts/signal.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSignalLock(store: WaSignalStore): WithDestroyLifecycle<WaSignalStore>;

package/dist/types/store/locks/thread.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaThreadStore } from '../contracts/thread.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withThreadLock(store: WaThreadStore): WithDestroyLifecycle<WaThreadStore>;

package/dist/types/store/providers/memory/appstate.store.d.ts

@@ -12,7 +12,7 @@ export declare class WaAppStateMemoryStore implements WaAppStateStore {
     constructor(initial?: WaAppStateStoreData, options?: WaAppStateMemoryStoreOptions);
     exportData(): Promise<WaAppStateStoreData>;
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeysBatch(keyIds: readonly Uint8Array[]): Promise<readonly (WaAppStateSyncKey | null)[]>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
     getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;

package/dist/types/store/providers/memory/privacy-token.store.d.ts

@@ -0,0 +1,13 @@
+import type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from '../../contracts/privacy-token.store';
+export declare class WaPrivacyTokenMemoryStore implements WaPrivacyTokenStore {
+    private readonly records;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    private mergeRecord;
+}

package/dist/types/store/providers/memory/retry.store.d.ts

@@ -2,14 +2,22 @@ import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../.
 import type { WaRetryStore } from '../../contracts/retry.store';
 export declare class WaRetryMemoryStore implements WaRetryStore {
     private readonly outboundMessages;
+    private readonly eligibleSets;
     private readonly inboundCounters;
     private readonly ttlMs;
     private readonly cleanupTimer;
     constructor(ttlMs?: number);
     getTtlMs(): number;
+    supportsRawReplayPayload(): boolean;
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, updatedAtMs: number, expiresAtMs: number): Promise<void>;
     incrementInboundCounter(messageId: string, requesterJid: string, _updatedAtMs: number, expiresAtMs: number): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/providers/memory/signal.store.d.ts

@@ -1,5 +1,5 @@
 import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
-import type { WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
+import type { WaSignalMetaSnapshot, WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
 export interface WaSignalMemoryStoreOptions {
     readonly maxPreKeys?: number;
     readonly maxSessions?: number;
@@ -35,6 +35,7 @@ export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     markKeyAsUploaded(keyId: number): Promise<void>;
     setServerHasPreKeys(value: boolean): Promise<void>;
     getServerHasPreKeys(): Promise<boolean>;
+    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
     hasSession(address: SignalAddress): Promise<boolean>;
     hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
     getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;

package/dist/types/store/types.d.ts

@@ -4,20 +4,14 @@ import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.store';
 import type { WaMessageStore } from './contracts/message.store';
 import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaPrivacyTokenStore } from './contracts/privacy-token.store';
 import type { WaRetryStore } from './contracts/retry.store';
 import type { WaSenderKeyStore } from './contracts/sender-key.store';
 import type { WaSignalStore } from './contracts/signal.store';
 import type { WaThreadStore } from './contracts/thread.store';
-export type WaSqliteDriver = 'auto' | 'better-sqlite3' | 'bun';
-export type WaSqliteTableName = 'wa_migrations' | 'auth_credentials' | 'signal_meta' | 'signal_registration' | 'signal_signed_prekey' | 'signal_prekey' | 'signal_session' | 'signal_identity' | 'sender_keys' | 'sender_key_distribution' | 'appstate_sync_keys' | 'appstate_collection_versions' | 'appstate_collection_index_values' | 'retry_outbound_messages' | 'retry_inbound_counters' | 'mailbox_messages' | 'mailbox_threads' | 'mailbox_contacts' | 'group_participants_cache' | 'device_list_cache';
-export type WaSqliteTableNameOverrides = Readonly<Partial<Record<WaSqliteTableName, string>>>;
-export interface WaSqliteStorageOptions {
-    readonly path: string;
-    readonly sessionId: string;
-    readonly driver?: WaSqliteDriver;
-    readonly pragmas?: Readonly<Record<string, string | number>>;
-    readonly tableNames?: WaSqliteTableNameOverrides;
-}
+export type WithDestroyLifecycle<T> = T & {
+    readonly destroy?: () => Promise<void>;
+};
 export interface WaStoreSession {
     readonly auth: WaAuthStore;
     readonly signal: WaSignalStore;
@@ -29,6 +23,7 @@ export interface WaStoreSession {
     readonly messages: WaMessageStore;
     readonly threads: WaThreadStore;
     readonly contacts: WaContactStore;
+    readonly privacyToken: WaPrivacyTokenStore;
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
@@ -37,30 +32,50 @@ export interface WaStore {
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
-export interface WaStoreProviderSelection {
-    readonly auth?: 'sqlite';
-    readonly signal?: 'sqlite' | 'memory';
-    readonly senderKey?: 'sqlite' | 'memory';
-    readonly appState?: 'sqlite' | 'memory';
-    readonly messages?: 'none' | 'sqlite' | 'memory';
-    readonly threads?: 'none' | 'sqlite' | 'memory';
-    readonly contacts?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheProviderSelection {
-    readonly retry?: 'sqlite' | 'memory';
-    readonly participants?: 'none' | 'sqlite' | 'memory';
-    readonly deviceList?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheTtlSelection {
-    readonly retryMs?: number;
-    readonly participantsMs?: number;
-    readonly deviceListMs?: number;
+export interface WaStoreBackend {
+    readonly stores: {
+        readonly auth: (sessionId: string) => WaAuthStore;
+        readonly signal: (sessionId: string) => WaSignalStore;
+        readonly senderKey: (sessionId: string) => WaSenderKeyStore;
+        readonly appState: (sessionId: string) => WaAppStateStore;
+        readonly messages: (sessionId: string) => WaMessageStore;
+        readonly threads: (sessionId: string) => WaThreadStore;
+        readonly contacts: (sessionId: string) => WaContactStore;
+        readonly privacyToken: (sessionId: string) => WaPrivacyTokenStore;
+    };
+    readonly caches: {
+        readonly retry: (sessionId: string) => WaRetryStore;
+        readonly participants: (sessionId: string) => WaParticipantsStore;
+        readonly deviceList: (sessionId: string) => WaDeviceListStore;
+    };
 }
-export interface WaStoreSqliteBatchSizeSelection {
-    readonly deviceList?: number;
-    readonly senderKeyDistribution?: number;
-    readonly signalPreKey?: number;
-    readonly signalHasSession?: number;
+export type WaStoreDomain = keyof WaStoreBackend['stores'];
+export type WaCacheDomain = keyof WaStoreBackend['caches'];
+export interface WaCreateStoreOptions<B extends string = string> {
+    readonly backends?: Readonly<Record<B, WaStoreBackend>>;
+    readonly providers?: {
+        readonly auth?: B | 'memory';
+        readonly signal?: B | 'memory';
+        readonly senderKey?: B | 'memory';
+        readonly appState?: B | 'memory';
+        readonly messages?: B | 'memory' | 'none';
+        readonly threads?: B | 'memory' | 'none';
+        readonly contacts?: B | 'memory' | 'none';
+        readonly privacyToken?: B | 'memory';
+    };
+    readonly cacheProviders?: {
+        readonly retry?: B | 'memory';
+        readonly participants?: B | 'memory' | 'none';
+        readonly deviceList?: B | 'memory' | 'none';
+    };
+    readonly memory?: {
+        readonly limits?: WaStoreMemoryLimitSelection;
+        readonly cacheTtlMs?: {
+            readonly retryMs?: number;
+            readonly participantsMs?: number;
+            readonly deviceListMs?: number;
+        };
+    };
 }
 export interface WaStoreMemoryLimitSelection {
     readonly appStateSyncKeys?: number;
@@ -75,32 +90,5 @@ export interface WaStoreMemoryLimitSelection {
     readonly messages?: number;
     readonly threads?: number;
     readonly contacts?: number;
-}
-export type WaStoreDomainValueOrFactory<T> = T | ((sessionId: string) => T);
-export interface WaCreateStoreCustomProviders {
-    readonly auth?: WaStoreDomainValueOrFactory<WaAuthStore>;
-    readonly signal?: WaStoreDomainValueOrFactory<WaSignalStore>;
-    readonly senderKey?: WaStoreDomainValueOrFactory<WaSenderKeyStore>;
-    readonly appState?: WaStoreDomainValueOrFactory<WaAppStateStore>;
-    readonly messages?: WaStoreDomainValueOrFactory<WaMessageStore>;
-    readonly threads?: WaStoreDomainValueOrFactory<WaThreadStore>;
-    readonly contacts?: WaStoreDomainValueOrFactory<WaContactStore>;
-}
-export interface WaCreateStoreCustomCacheProviders {
-    readonly retry?: WaStoreDomainValueOrFactory<WaRetryStore>;
-    readonly participants?: WaStoreDomainValueOrFactory<WaParticipantsStore>;
-    readonly deviceList?: WaStoreDomainValueOrFactory<WaDeviceListStore>;
-}
-export interface WaCreateStoreOptions {
-    readonly sqlite?: Omit<WaSqliteStorageOptions, 'sessionId'> & {
-        readonly batchSizes?: WaStoreSqliteBatchSizeSelection;
-    };
-    readonly memory?: {
-        readonly limits?: WaStoreMemoryLimitSelection;
-    };
-    readonly providers?: WaStoreProviderSelection;
-    readonly cacheProviders?: WaStoreCacheProviderSelection;
-    readonly cacheTtlMs?: WaStoreCacheTtlSelection;
-    readonly custom?: WaCreateStoreCustomProviders;
-    readonly customCache?: WaCreateStoreCustomCacheProviders;
+    readonly privacyTokens?: number;
 }

package/dist/types/transport/WaWebSocket.d.ts

@@ -15,7 +15,6 @@ export declare class WaWebSocket {
     setHandlers(handlers: WaSocketHandlers): void;
     isOpen(): boolean;
     isConnecting(): boolean;
-    getReadyState(): number;
     open(): Promise<SocketOpenInfo>;
     close(code?: number, reason?: string): Promise<SocketCloseInfo | null>;
     send(data: string | ArrayBuffer | Uint8Array): Promise<void>;

package/dist/types/transport/binary/constants.d.ts

@@ -17,33 +17,3 @@ export declare const NIBBLE_ALPHABET: readonly string[];
 export declare const HEX_ALPHABET: readonly string[];
 export declare const SINGLE_BYTE_TOKEN_MAP: ReadonlyMap<string, number>;
 export declare const DICTIONARY_TOKEN_MAPS: readonly ReadonlyMap<string, number>[];
-export declare const WAP_ENCODE_CONSTANTS: Readonly<{
-    LIST_EMPTY: 0;
-    LIST_8: 248;
-    LIST_16: 249;
-    JID_PAIR: 250;
-    HEX_8: 251;
-    BINARY_8: 252;
-    BINARY_20: 253;
-    BINARY_32: 254;
-    NIBBLE_8: 255;
-    DICTIONARY_0: 236;
-    DICTIONARY_3: 239;
-}>;
-export declare const WAP_DECODE_CONSTANTS: Readonly<{
-    LIST_EMPTY: 0;
-    LIST_8: 248;
-    LIST_16: 249;
-    JID_PAIR: 250;
-    JID_FB: 246;
-    JID_INTEROP: 245;
-    JID_U: 247;
-    HEX_8: 251;
-    BINARY_8: 252;
-    BINARY_20: 253;
-    BINARY_32: 254;
-    NIBBLE_8: 255;
-    DICTIONARY_0: 236;
-    DICTIONARY_3: 239;
-    STREAM_END: 2;
-}>;

package/dist/types/transport/binary/index.d.ts

@@ -1,4 +1,3 @@
 export * from '../binary/tokens';
 export * from '../binary/encoder';
 export * from '../binary/decoder';
-export { WAP_DECODE_CONSTANTS as WapDecodeConstants, WAP_ENCODE_CONSTANTS as WapEncodeConstants } from '../binary/constants';

package/dist/types/transport/node/WaNodeOrchestrator.d.ts

@@ -11,8 +11,8 @@ export declare class WaNodeOrchestrator {
     private readonly sendNodeFn;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
-    private stanzaPrefix;
-    private stanzaCounter;
+    private idGenerator;
+    private idGeneratorReady;
     private readonly pendingQueries;
     constructor(options: WaNodeOrchestratorOptions);
     hasPending(): boolean;
@@ -22,7 +22,6 @@ export declare class WaNodeOrchestrator {
     sendNode(node: BinaryNode): Promise<void>;
     query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
     private withAutoId;
-    private getStanzaPrefix;
-    private generateStanzaPrefix;
+    private getIdGenerator;
 }
 export {};

package/dist/types/transport/node/builders/business.d.ts

@@ -0,0 +1,29 @@
+import type { BinaryNode } from '../../types';
+export declare const WA_BUSINESS_PROFILE_VERSION = 116;
+export interface WaEditBusinessProfileInput {
+    readonly address?: string;
+    readonly description?: string;
+    readonly email?: string;
+    readonly websites?: readonly {
+        readonly url: string;
+    }[];
+    readonly categories?: readonly {
+        readonly id: string;
+    }[];
+    readonly businessHours?: {
+        readonly timezone?: string;
+        readonly config: readonly {
+            readonly dayOfWeek: string;
+            readonly mode: string;
+            readonly openTime?: number;
+            readonly closeTime?: number;
+        }[];
+    };
+    readonly latitude?: number;
+    readonly longitude?: number;
+}
+export declare function buildGetBusinessProfileIq(jids: readonly string[], version?: number): BinaryNode;
+export declare function buildEditBusinessProfileIq(input: WaEditBusinessProfileInput): BinaryNode;
+export declare function buildGetVerifiedNameIq(jid: string): BinaryNode;
+export declare function buildUpdateCoverPhotoIq(id: string, timestamp: string, token: string): BinaryNode;
+export declare function buildDeleteCoverPhotoIq(id: string): BinaryNode;

package/dist/types/transport/node/builders/global.d.ts

@@ -0,0 +1,102 @@
+import type { BinaryNode } from '../../types';
+export type BuildAckNodeInput = {
+    readonly kind: 'notification';
+    readonly node: BinaryNode;
+    readonly typeOverride?: string;
+    readonly includeParticipant?: boolean;
+    readonly includeType?: boolean;
+    readonly content?: BinaryNode[];
+} | {
+    readonly kind: 'message';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+    readonly from?: string | null;
+    readonly typeOverride?: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+} | {
+    readonly kind: 'receipt';
+    readonly node: BinaryNode;
+    readonly retryType?: boolean;
+    readonly typeOverride?: string;
+    readonly includeParticipant?: boolean;
+    readonly includeRecipient?: boolean;
+} | {
+    readonly kind: 'aggregate_message';
+    readonly to: string;
+    readonly ids: readonly string[];
+    readonly recipient?: string;
+    readonly participant?: string;
+    readonly type?: string;
+} | {
+    readonly kind: 'nack';
+    readonly stanzaTag: string;
+    readonly id: string;
+    readonly to: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly error: number | string;
+    readonly failureReason?: number;
+} | {
+    readonly kind: 'custom';
+    readonly ackClass: string;
+    readonly to: string;
+    readonly id?: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly from?: string;
+    readonly error?: number | string;
+    readonly content?: BinaryNode[];
+};
+export declare function buildAckNode(input: BuildAckNodeInput): BinaryNode;
+export type BuildReceiptNodeInput = {
+    readonly kind: 'delivery';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+} | {
+    readonly kind: 'retry_custom';
+    readonly id: string;
+    readonly to: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly categoryPeer?: boolean;
+    readonly content: BinaryNode[];
+} | {
+    readonly kind: 'retry';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+    readonly retryCount?: number;
+} | {
+    readonly kind: 'outbound';
+    readonly id: string;
+    readonly to: 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?: BinaryNode[];
+} | {
+    readonly kind: 'server_error';
+    readonly id: string;
+    readonly to: string;
+    readonly categoryPeer?: boolean;
+    readonly encryptCiphertext: Uint8Array;
+    readonly encryptIv: Uint8Array;
+    readonly rmrJid?: string;
+    readonly rmrFromMe?: boolean | string;
+    readonly rmrParticipant?: string;
+} | {
+    readonly kind: 'custom';
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly content?: BinaryNode[];
+};
+export declare function buildReceiptNode(input: BuildReceiptNodeInput): BinaryNode;
+export declare function buildIqResultNode(iqNode: BinaryNode): BinaryNode;

package/dist/types/transport/node/builders/index.d.ts

@@ -1,8 +1,11 @@
 export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/account-sync';
-export { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode, buildIqResultNode, buildNotificationAckNode } from '../../node/builders/pairing';
+export { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode } from '../../node/builders/pairing';
+export { buildAckNode, buildReceiptNode, buildIqResultNode } from '../../node/builders/global';
 export { buildMediaConnIq } from '../../node/builders/media';
-export { buildDirectMessageFanoutNode, buildGroupDirectMessageNode, buildGroupRetryMessageNode, buildGroupSenderKeyMessageNode, buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundReceiptAckNode, buildInboundRetryReceiptNode, buildInboundRetryReceiptAckNode } from '../../node/builders/message';
+export { buildDirectMessageFanoutNode, buildGroupRetryMessageNode, buildGroupSenderKeyMessageNode, buildMetaNode } from '../../node/builders/message';
 export { buildRetryReceiptNode } from '../../node/builders/retry';
 export { buildMissingPreKeysFetchIq, buildPreKeyUploadIq, buildSignedPreKeyRotateIq } from '../../node/builders/prekeys';
 export { buildCreateGroupIq, buildGroupParticipantChangeIq, buildLeaveGroupIq } from '../../node/builders/group';
 export { buildUsyncIq, buildUsyncUserNode, type BuildUsyncIqInput, type BuildUsyncUserNodeInput, type WaUsyncContext, type WaUsyncMode } from '../../node/builders/usync';
+export { buildDeleteProfilePictureIq, buildGetProfilePictureIq, buildGetStatusUsyncQueryNodes, buildSetProfilePictureIq, type WaProfilePictureType } from '../../node/builders/profile';
+export { buildDeleteCoverPhotoIq, buildEditBusinessProfileIq, buildGetBusinessProfileIq, buildGetVerifiedNameIq, buildUpdateCoverPhotoIq, WA_BUSINESS_PROFILE_VERSION, type WaEditBusinessProfileInput } from '../../node/builders/business';

package/dist/types/transport/node/builders/message.d.ts

@@ -8,9 +8,13 @@ type DirectMessageFanoutInput = {
     readonly to: string;
     readonly type: string;
     readonly id?: string;
+    readonly edit?: string;
     readonly participants: readonly EncryptedParticipant[];
     readonly deviceIdentity?: Uint8Array;
     readonly reportingNode?: BinaryNode;
+    readonly privacyTokenNode?: BinaryNode;
+    readonly metaNode?: BinaryNode;
+    readonly mediatype?: string;
 };
 type GroupMessageFanoutInput = DirectMessageFanoutInput & {
     readonly phash?: string;
@@ -27,15 +31,12 @@ type GroupRetryMessageInput = {
     readonly addressingMode: 'pn' | 'lid';
     readonly encType: 'msg' | 'pkmsg';
     readonly ciphertext: Uint8Array;
+    readonly retryCount: number;
     readonly deviceIdentity?: Uint8Array;
+    readonly mediatype?: string;
 };
-export declare function buildDirectMessageFanoutNode(input: DirectMessageFanoutInput): BinaryNode;
+export declare function buildDirectMessageFanoutNode(input: GroupMessageFanoutInput): BinaryNode;
 export declare function buildGroupSenderKeyMessageNode(input: GroupSenderKeyMessageInput): BinaryNode;
-export declare function buildGroupDirectMessageNode(input: GroupMessageFanoutInput): BinaryNode;
-export declare function buildInboundMessageAckNode(messageNode: BinaryNode, id: string, to: string, meJid: string | null | undefined): BinaryNode;
-export declare function buildInboundDeliveryReceiptNode(messageNode: BinaryNode, id: string, to: string): BinaryNode;
-export declare function buildInboundRetryReceiptNode(messageNode: BinaryNode, id: string, to: string, meJid?: string | null, retryCount?: number): BinaryNode;
-export declare function buildInboundRetryReceiptAckNode(receiptNode: BinaryNode): BinaryNode;
-export declare function buildInboundReceiptAckNode(receiptNode: BinaryNode): BinaryNode;
 export declare function buildGroupRetryMessageNode(input: GroupRetryMessageInput): BinaryNode;
+export declare function buildMetaNode(attrs: Record<string, string>): BinaryNode;
 export {};

package/dist/types/transport/node/builders/pairing.d.ts

@@ -14,5 +14,3 @@ export declare function buildCompanionFinishRequestNode(args: {
     readonly companionIdentityPublic: Uint8Array;
     readonly ref: Uint8Array;
 }): BinaryNode;
-export declare function buildNotificationAckNode(node: BinaryNode, typeOverride?: string): BinaryNode;
-export declare function buildIqResultNode(iqNode: BinaryNode): BinaryNode;

package/dist/types/transport/node/builders/privacy-token.d.ts

@@ -0,0 +1,9 @@
+import type { BinaryNode } from '../../types';
+export interface BuildPrivacyTokenIqInput {
+    readonly jid: string;
+    readonly timestampS: number;
+    readonly type?: string;
+}
+export declare function buildPrivacyTokenIqNode(input: BuildPrivacyTokenIqInput): BinaryNode;
+export declare function buildTcTokenMessageNode(token: Uint8Array): BinaryNode;
+export declare function buildCsTokenMessageNode(hash: Uint8Array): BinaryNode;

package/dist/types/transport/node/builders/privacy.d.ts

@@ -0,0 +1,7 @@
+import { type WaPrivacyCategory, type WaPrivacyValue } from '../../../protocol/privacy';
+import type { BinaryNode } from '../../types';
+export declare function buildGetPrivacySettingsIq(): BinaryNode;
+export declare function buildSetPrivacyCategoryIq(category: WaPrivacyCategory, value: WaPrivacyValue): BinaryNode;
+export declare function buildGetPrivacyDisallowedListIq(category: WaPrivacyCategory): BinaryNode;
+export declare function buildGetBlocklistIq(): BinaryNode;
+export declare function buildBlocklistChangeIq(jid: string, action: 'block' | 'unblock'): BinaryNode;

package/dist/types/transport/node/builders/profile.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryNode } from '../../types';
+export type WaProfilePictureType = 'preview' | 'image';
+export declare function buildGetProfilePictureIq(targetJid: string, type?: WaProfilePictureType, existingId?: string): BinaryNode;
+export declare function buildSetProfilePictureIq(imageBytes: Uint8Array, targetJid?: string): BinaryNode;
+export declare function buildDeleteProfilePictureIq(targetJid?: string): BinaryNode;
+export declare function buildSetStatusIq(text: string): BinaryNode;
+export declare function buildGetDisappearingModeUsyncQueryNode(): BinaryNode;
+export declare function buildGetStatusUsyncQueryNodes(): readonly BinaryNode[];

package/dist/types/transport/node/builders/retry.d.ts

@@ -5,7 +5,6 @@ export declare function buildRetryReceiptNode(input: {
     readonly to: string;
     readonly participant?: string;
     readonly recipient?: string;
-    readonly from?: string;
     readonly originalMsgId: string;
     readonly retryCount: number;
     readonly t: string;

package/dist/types/transport/node/helpers.d.ts

@@ -1,4 +1,8 @@
 import type { BinaryNode } from '../types';
+export interface NodeIdGenerator {
+    readonly prefix: string;
+    next(): string;
+}
 export declare function getNodeChildren(node: BinaryNode): readonly BinaryNode[];
 export declare function findNodeChild(node: BinaryNode, tag: string): BinaryNode | undefined;
 export declare function getFirstNodeChild(node: BinaryNode): BinaryNode | undefined;
@@ -14,3 +18,4 @@ export declare function hasNodeChild(node: BinaryNode, tag: string): boolean;
 export declare function decodeNodeContentUtf8OrBytes(value: BinaryNode['content'], field: string): Uint8Array;
 export declare function decodeNodeContentBase64OrBytes(value: BinaryNode['content'], field: string): Uint8Array;
 export declare function formatNodeIdPrefixFromSeed(seed: Uint8Array): string;
+export declare function createNodeIdGenerator(): Promise<NodeIdGenerator>;

package/dist/types/transport/noise/WaNoiseSession.d.ts

@@ -3,8 +3,8 @@ import type { WaNoiseConfig } from '../types';
 export declare class WaNoiseSession {
     private readonly sendWire;
     private readonly logger;
-    private readonly writeQueue;
-    private readonly readQueue;
+    private writeChain;
+    private readChain;
     private frameCodec;
     private handshakeInbox;
     private handshakeInboxHead;
@@ -20,6 +20,7 @@ export declare class WaNoiseSession {
     encryptFrame(frame: Uint8Array): Promise<Uint8Array>;
     pushWireChunk(chunk: Uint8Array): Promise<readonly Uint8Array[]>;
     onSocketClosed(error?: Error): void;
+    private decryptFramesBatch;
     reset(): void;
     getServerStaticKey(): Uint8Array | null;
     private fullHandshake;