zapo-js 0.1.1 → 0.2.0

package/dist/types/transport/keepalive/WaKeepAlive.d.ts

@@ -32,7 +32,6 @@ export declare class WaKeepAlive {
     private schedule;
     private run;
     private normalizeJitterRatio;
-    private normalizeMinJitterMs;
     private computeNextDelayMs;
     private clearTimer;
 }

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/WaNodeTransport.d.ts

@@ -2,21 +2,12 @@ import { EventEmitter } from 'node:events';
 import type { Logger } from '../../infra/log/types';
 import type { BinaryNode } from '../types';
 import type { WaComms } from '../WaComms';
-interface NodeTransportEventMap {
-    readonly frame_in: (frame: Uint8Array) => void;
-    readonly frame_out: (frame: Uint8Array) => void;
-    readonly node_in: (node: BinaryNode, frame: Uint8Array) => void;
-    readonly node_out: (node: BinaryNode, frame: Uint8Array) => void;
-    readonly decode_error: (error: Error, frame: Uint8Array) => void;
-}
 export declare class WaNodeTransport extends EventEmitter {
     private readonly logger;
     private comms;
     constructor(logger?: Logger);
-    on<K extends keyof NodeTransportEventMap>(event: K, listener: NodeTransportEventMap[K]): this;
     bindComms(comms: WaComms | null): void;
     sendNode(node: BinaryNode): Promise<void>;
     dispatchIncomingFrame(frame: Uint8Array, onNode: (node: BinaryNode) => Promise<void> | void): Promise<void>;
     private shouldIncludeTraceXml;
 }
-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/group.d.ts

@@ -1,16 +1,14 @@
 import type { BinaryNode } from '../../types';
-interface BuildCreateGroupIqInput {
+export declare function buildCreateGroupIq(input: {
     readonly subject: string;
     readonly participants: readonly string[];
     readonly description?: string;
-}
-export declare function buildCreateGroupIq(input: BuildCreateGroupIqInput): BinaryNode;
+}): BinaryNode;
 type GroupParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
-interface BuildGroupParticipantChangeIqInput {
+export declare function buildGroupParticipantChangeIq(input: {
     readonly groupJid: string;
     readonly action: GroupParticipantAction;
     readonly participants: readonly string[];
-}
-export declare function buildGroupParticipantChangeIq(input: BuildGroupParticipantChangeIqInput): BinaryNode;
+}): BinaryNode;
 export declare function buildLeaveGroupIq(groupJids: readonly string[]): BinaryNode;
 export {};

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

@@ -1,7 +1,11 @@
-export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/accountSync';
-export { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode, buildIqResultNode, buildNotificationAckNode } from '../../node/builders/pairing';
+export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/account-sync';
+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

@@ -4,33 +4,26 @@ interface EncryptedParticipant {
     readonly encType: 'msg' | 'pkmsg';
     readonly ciphertext: Uint8Array;
 }
-interface BuildDirectMessageFanoutNodeInput {
+type DirectMessageFanoutInput = {
     readonly to: string;
     readonly type: string;
     readonly id?: string;
+    readonly edit?: string;
     readonly participants: readonly EncryptedParticipant[];
     readonly deviceIdentity?: Uint8Array;
-}
-interface BuildGroupSenderKeyMessageNodeInput {
-    readonly to: string;
-    readonly type: string;
-    readonly groupCiphertext: Uint8Array;
-    readonly id?: string;
-    readonly phash?: string;
-    readonly addressingMode?: 'pn' | 'lid';
-    readonly participants: readonly EncryptedParticipant[];
-    readonly deviceIdentity?: Uint8Array;
-}
-interface BuildGroupDirectMessageNodeInput {
-    readonly to: string;
-    readonly type: string;
-    readonly id?: string;
+    readonly reportingNode?: BinaryNode;
+    readonly privacyTokenNode?: BinaryNode;
+    readonly metaNode?: BinaryNode;
+    readonly mediatype?: string;
+};
+type GroupMessageFanoutInput = DirectMessageFanoutInput & {
     readonly phash?: string;
     readonly addressingMode?: 'pn' | 'lid';
-    readonly participants: readonly EncryptedParticipant[];
-    readonly deviceIdentity?: Uint8Array;
-}
-interface BuildGroupRetryMessageNodeInput {
+};
+type GroupSenderKeyMessageInput = GroupMessageFanoutInput & {
+    readonly groupCiphertext: Uint8Array;
+};
+type GroupRetryMessageInput = {
     readonly to: string;
     readonly type: string;
     readonly id: string;
@@ -38,15 +31,12 @@ interface BuildGroupRetryMessageNodeInput {
     readonly addressingMode: 'pn' | 'lid';
     readonly encType: 'msg' | 'pkmsg';
     readonly ciphertext: Uint8Array;
+    readonly retryCount: number;
     readonly deviceIdentity?: Uint8Array;
-}
-export declare function buildDirectMessageFanoutNode(input: BuildDirectMessageFanoutNodeInput): BinaryNode;
-export declare function buildGroupSenderKeyMessageNode(input: BuildGroupSenderKeyMessageNodeInput): BinaryNode;
-export declare function buildGroupDirectMessageNode(input: BuildGroupDirectMessageNodeInput): 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: BuildGroupRetryMessageNodeInput): BinaryNode;
+    readonly mediatype?: string;
+};
+export declare function buildDirectMessageFanoutNode(input: GroupMessageFanoutInput): BinaryNode;
+export declare function buildGroupSenderKeyMessageNode(input: GroupSenderKeyMessageInput): 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

@@ -1,11 +1,10 @@
 import type { WaRetryKeyBundle } from '../../../retry/types';
 import type { BinaryNode } from '../../types';
-interface BuildRetryReceiptNodeInput {
+export declare function buildRetryReceiptNode(input: {
     readonly stanzaId: string;
     readonly to: string;
     readonly participant?: string;
     readonly recipient?: string;
-    readonly from?: string;
     readonly originalMsgId: string;
     readonly retryCount: number;
     readonly t: string;
@@ -13,6 +12,4 @@ interface BuildRetryReceiptNodeInput {
     readonly error?: number;
     readonly categoryPeer?: boolean;
     readonly keys?: WaRetryKeyBundle;
-}
-export declare function buildRetryReceiptNode(input: BuildRetryReceiptNodeInput): BinaryNode;
-export {};
+}): BinaryNode;

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

@@ -0,0 +1,21 @@
+import { WA_USYNC_CONTEXTS, WA_USYNC_MODES } from '../../../protocol/constants';
+import type { BinaryNode } from '../../types';
+export type WaUsyncMode = (typeof WA_USYNC_MODES)[keyof typeof WA_USYNC_MODES];
+export type WaUsyncContext = (typeof WA_USYNC_CONTEXTS)[keyof typeof WA_USYNC_CONTEXTS];
+export interface BuildUsyncUserNodeInput {
+    readonly jid: string;
+    readonly attrs?: Readonly<Record<string, string>>;
+    readonly content?: BinaryNode['content'];
+}
+export interface BuildUsyncIqInput {
+    readonly sid: string;
+    readonly queryProtocolNodes: readonly BinaryNode[];
+    readonly users: readonly BuildUsyncUserNodeInput[];
+    readonly mode?: WaUsyncMode;
+    readonly context?: WaUsyncContext;
+    readonly index?: string;
+    readonly last?: string;
+    readonly hostDomain?: string;
+}
+export declare function buildUsyncUserNode(input: BuildUsyncUserNodeInput): BinaryNode;
+export declare function buildUsyncIq(input: BuildUsyncIqInput): BinaryNode;

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

@@ -1,8 +1,21 @@
 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;
 export declare function getNodeChildrenByTag(node: BinaryNode, tag: string): readonly BinaryNode[];
+export declare function getNodeChildrenByTagFromChildren(node: BinaryNode, tag: string): readonly BinaryNode[];
+export declare function getNodeChildrenTags(node: BinaryNode): readonly string[];
+export declare function getNodeChildrenNonEmptyAttrValuesByTag(node: BinaryNode, tag: string, attr: string): readonly string[];
+export declare function getNodeChildrenNonEmptyUtf8ByTag(node: BinaryNode, tag: string, field: string): readonly string[];
+export declare function findNodeChildrenByTags<const TTags extends readonly string[]>(node: BinaryNode, tags: TTags): {
+    readonly [Index in keyof TTags]: BinaryNode | undefined;
+};
 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/node/usync.d.ts

@@ -0,0 +1,2 @@
+export type WaUsyncSidGenerator = () => Promise<string>;
+export declare function createUsyncSidGenerator(): WaUsyncSidGenerator;

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

@@ -3,7 +3,10 @@ export declare class WaFrameCodec {
     private readonly maxFrameLength;
     private introSent;
     private buffered;
+    private bufferedLength;
     constructor(introFrame?: Uint8Array, maxFrameLength?: number);
+    private assertFrameLength;
+    private appendBuffered;
     encodeFrame(frame: Uint8Array): Uint8Array;
     pushWireChunk(chunk: Uint8Array): readonly Uint8Array[];
 }

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

@@ -3,10 +3,11 @@ 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;
     private handshakeWaiter;
     private handshakeRejecter;
     private pendingDecryptedFrames;
@@ -19,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;

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

@@ -5,6 +5,8 @@ export declare class WaNoiseSocket {
     private writeCounter;
     private readCounter;
     constructor(encryptKey: CryptoKey, decryptKey: CryptoKey);
-    encrypt(frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
-    decrypt(frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
+    reserveWriteNonce(): Uint8Array;
+    encrypt(nonce: Uint8Array, frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
+    reserveReadNonce(): Uint8Array;
+    decrypt(nonce: Uint8Array, frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
 }

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

@@ -0,0 +1,6 @@
+import type { WaProxyAgent, WaProxyDispatcher, WaProxyTransport } from './types';
+export declare function isProxyDispatcher(value: unknown): value is WaProxyDispatcher;
+export declare function isProxyAgent(value: unknown): value is WaProxyAgent;
+export declare function isProxyTransport(value: unknown): value is WaProxyTransport;
+export declare function toProxyDispatcher(proxy: WaProxyTransport | undefined): WaProxyDispatcher | undefined;
+export declare function toProxyAgent(proxy: WaProxyTransport | undefined): WaProxyAgent | undefined;

package/dist/types/transport/stream/parse.d.ts

@@ -18,6 +18,5 @@ export type WaStreamControlNodeResult = {
     readonly kind: 'stream_error_other';
 };
 export declare function parseStreamControlNode(node: BinaryNode): WaStreamControlNodeResult | null;
-export declare function parseOptionalInt(value: string | undefined): number | undefined;
 export declare function parseCompanionEncStatic(value: string | undefined, onError?: (error: Error) => void): Uint8Array | undefined;
 export declare function parseSuccessPersistAttributes(node: BinaryNode, onCompanionParseError?: (error: Error) => void): WaSuccessPersistAttributes;

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

@@ -1,5 +1,12 @@
+import type { Agent as HttpAgent } from 'node:http';
+import type { Agent as HttpsAgent } from 'node:https';
 import type { SignalKeyPair } from '../crypto/curves/types';
 import type { WaLoginPayloadConfig, WaRegistrationPayloadConfig } from './noise/types';
+export interface WaProxyDispatcher {
+    dispatch(...args: readonly unknown[]): unknown;
+}
+export type WaProxyAgent = HttpAgent | HttpsAgent;
+export type WaProxyTransport = WaProxyDispatcher | WaProxyAgent;
 export interface BinaryNode {
     readonly tag: string;
     readonly attrs: Readonly<Record<string, string>>;
@@ -18,6 +25,8 @@ export interface WaSocketConfig {
     readonly urls?: readonly string[];
     readonly protocols?: readonly string[];
     readonly headers?: Readonly<Record<string, string>>;
+    readonly dispatcher?: WaProxyDispatcher;
+    readonly agent?: WaProxyAgent;
     readonly timeoutIntervalMs?: number;
 }
 export interface WaSocketHandlers {
@@ -66,6 +75,14 @@ export interface RawWebSocket {
     close(code?: number, reason?: string): void;
     send(data: string | ArrayBuffer | Uint8Array): void;
 }
-export type RawWebSocketConstructor = new (url: string, protocols?: string | readonly string[], options?: {
+export interface WaRawWebSocketInit {
+    readonly protocols?: string | readonly string[];
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly dispatcher?: WaProxyDispatcher;
+    readonly agent?: WaProxyAgent;
+}
+export type RawWebSocketConstructor = new (url: string, protocols?: string | readonly string[] | WaRawWebSocketInit, options?: {
     headers?: Readonly<Record<string, string>>;
+    dispatcher?: WaProxyDispatcher;
+    agent?: WaProxyAgent;
 }) => RawWebSocket;

package/dist/types/util/bytes.d.ts

@@ -1,6 +1,7 @@
 import type { Readable } from 'node:stream';
 export declare const TEXT_ENCODER: import("../util").TextEncoder;
 export declare const TEXT_DECODER: import("../util").TextDecoder;
+export declare const ZERO_BYTES: Readonly<Uint8Array>;
 export declare const EMPTY_BYTES: Readonly<Uint8Array<ArrayBuffer>>;
 /**
  * Encodes a Uint8Array to a hex string
@@ -12,6 +13,10 @@ export declare function bytesToHex(value: Uint8Array): string;
 export declare function hexToBytes(value: string): Uint8Array;
 export declare function bytesToBase64(value: Uint8Array): string;
 export declare function base64ToBytes(value: string): Uint8Array;
+export declare function base64ToBytesChecked(value: string, field: string, requireNonEmpty?: boolean): Uint8Array;
+export declare function decodeBase64Url(value: string | undefined, field: string): Uint8Array;
+export declare function assertByteLength(value: Uint8Array, expectedLength: number, errorMessage: string): void;
+export declare function decodeProtoBytes(value: Uint8Array | string | null | undefined, field: string): Uint8Array;
 /**
  * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
  */

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

@@ -0,0 +1,5 @@
+export { bytesToHex, hexToBytes, toBytesView, uint8Equal } from './bytes';
+export { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, asString, resolvePositive, toBoolOrUndef } from './coercion';
+export { normalizeQueryLimit } from './collections';
+export { toSafeNumber } from './primitives';
+export { isBunRuntime } from './runtime';

package/dist/types/util/primitives.d.ts

@@ -5,3 +5,5 @@ export declare function toSafeNumber(value: number | {
 export declare function longToNumber(value: number | {
     toNumber(): number;
 } | null | undefined): number;
+export declare function normalizeNonNegativeInteger(value: number | undefined, fallback: number): number;
+export declare function parseOptionalInt(value: string | undefined): number | undefined;