zapo-js 0.3.0 → 1.0.1

package/dist/types/client/coordinators/WaRetryCoordinator.d.ts

@@ -1,9 +1,13 @@
+import type { WaAuthCredentials } from '../../auth/types';
+import type { WaIncomingMessageEvent } from '../types';
 import type { Logger } from '../../infra/log/types';
+import type { IcdcMeta } from '../../message/crypto/icdc';
+import type { PeerDataOperationRequester } from '../../message/primitives/peer-data-operation';
 import type { WaMessageClient } from '../../message/WaMessageClient';
-import { type Proto } from '../..';
 import type { WaRetryDecryptFailureContext } from '../../retry/types';
 import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
 import type { SignalMissingPreKeysSyncApi } from '../../signal/api/SignalMissingPreKeysSyncApi';
+import type { SignalSessionResolver } from '../../signal/session/resolver';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
 import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaRetryStore } from '../../store/contracts/retry.store';
@@ -19,39 +23,34 @@ interface WaRetryCoordinatorOptions {
     readonly sessionStore: WaSessionStore;
     readonly senderKeyStore: WaSenderKeyStore;
     readonly signalProtocol: SignalProtocol;
+    readonly sessionResolver: SignalSessionResolver;
     readonly signalDeviceSync: SignalDeviceSyncApi;
     readonly signalMissingPreKeysSync: SignalMissingPreKeysSyncApi;
     readonly messageClient: WaMessageClient;
     readonly sendNode: (node: BinaryNode) => Promise<void>;
-    readonly getCurrentMeJid: () => string | null | undefined;
-    readonly getCurrentMeLid: () => string | null | undefined;
-    readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
+    /** Refresh device-list ICDC for the given user jid; passed through to retry replay. */
+    readonly resolveUserIcdc?: (userJid: string) => Promise<IcdcMeta | null>;
+    readonly peerDataOperation?: PeerDataOperationRequester;
+    readonly emitIncomingMessage?: (event: WaIncomingMessageEvent) => void;
 }
 export declare class WaRetryCoordinator {
-    private readonly logger;
-    private readonly retryStore;
+    private readonly deps;
     private readonly retryTtlMs;
-    private readonly signalStore;
-    private readonly preKeyStore;
-    private readonly sessionStore;
-    private readonly senderKeyStore;
-    private readonly signalProtocol;
-    private readonly signalDeviceSync;
-    private readonly signalMissingPreKeysSync;
     private readonly retryReplayService;
-    private readonly sendNode;
-    private readonly getCurrentMeJid;
-    private readonly getCurrentMeLid;
-    private readonly getCurrentSignedIdentity;
     private readonly retryProcessingByMessageId;
     private readonly retrySessionBaseKeys;
     private nextRetryCleanupAtMs;
+    private readonly placeholderInFlight;
+    private placeholderQueue;
+    private placeholderTimer;
     constructor(options: WaRetryCoordinatorOptions);
     onDecryptFailure(context: WaRetryDecryptFailureContext, error: unknown): Promise<boolean>;
     handleIncomingRetryReceipt(receiptNode: BinaryNode): Promise<void>;
     private isRetryReceiptNode;
     private prepareDecryptFailureRetry;
     private sendDecryptFailureRetryReceipt;
+    private resolvePeerRetryRecipient;
     private handleParsedRetryRequest;
     private processRetryRequest;
     private prepareRetryResend;
@@ -71,5 +70,8 @@ export declare class WaRetryCoordinator {
     private setRetrySessionBaseKey;
     private getRetrySessionBaseKey;
     private cleanupRetrySessionBaseKeys;
+    private isSenderFromOwnAccount;
+    private enqueuePlaceholderResend;
+    private flushPlaceholderBatch;
 }
 export {};

package/dist/types/client/coordinators/WaStatusCoordinator.d.ts

@@ -0,0 +1,42 @@
+import type { WaAppStateMutationCoordinator, WaSetStatusPrivacyInput } from '../coordinators/WaAppStateMutationCoordinator';
+import type { WaSendMessageOptions } from '../types';
+import type { WaMessageBuildResult, WaMessagePublishResult, WaSendMessageContent } from '../../message/types';
+import { type Proto } from '../../proto';
+import type { WaStatusDistributionSetting } from '../../protocol/status';
+export interface WaStatusCoordinatorOptions {
+    readonly appStateMutations: WaAppStateMutationCoordinator;
+    readonly buildMessageContent: (content: WaSendMessageContent) => Promise<WaMessageBuildResult>;
+    readonly publishStatusMessage: (input: {
+        readonly message: Proto.IMessage;
+        readonly recipients: readonly string[];
+        readonly statusSetting?: WaStatusDistributionSetting;
+        readonly options?: WaSendMessageOptions;
+    }) => Promise<WaMessagePublishResult>;
+}
+export interface WaSendStatusInput {
+    readonly content: WaSendMessageContent;
+    readonly recipients: readonly string[];
+    readonly statusSetting?: WaStatusDistributionSetting;
+    readonly options?: WaSendMessageOptions;
+}
+/**
+ * Coordinates the status-broadcast surface: distribution privacy, per-contact
+ * mute, send, and revoke. Accessed via {@link WaClient.status}.
+ */
+export interface WaStatusCoordinator {
+    /** Updates the account-wide status privacy setting (see {@link WaSetStatusPrivacyInput}). */
+    readonly setPrivacy: (input: WaSetStatusPrivacyInput) => Promise<void>;
+    /** Mutes or unmutes a specific contact's status broadcasts. */
+    readonly setUserMuted: (jid: string, muted: boolean) => Promise<void>;
+    /** Publishes a status broadcast to the given recipients. */
+    readonly send: (input: WaSendStatusInput) => Promise<WaMessagePublishResult>;
+    /** Revokes a previously-published status broadcast. */
+    readonly revokeStatus: (input: {
+        readonly messageId: string;
+        readonly recipients: readonly string[];
+        readonly statusSetting?: WaStatusDistributionSetting;
+        readonly options?: WaSendMessageOptions;
+    }) => Promise<WaMessagePublishResult>;
+}
+/** Builds a {@link WaStatusCoordinator} from its dependencies. */
+export declare function createStatusCoordinator(options: WaStatusCoordinatorOptions): WaStatusCoordinator;

package/dist/types/client/coordinators/WaTrustedContactTokenCoordinator.d.ts

@@ -1,12 +1,14 @@
+import type { WaAuthCredentials } from '../../auth/types';
 import type { ParsedPrivacyToken } from '../events/privacy-token';
 import type { WaClientEventMap } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { WaPrivacyTokenStore } from '../../store/contracts/privacy-token.store';
 import type { BinaryNode } from '../../transport/types';
+import type { ServerClock } from '../../util/clock';
 type WaTrustedContactTokenRuntime = {
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
-    readonly getCurrentMeLid: () => string | null;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
 };
 interface WaTrustedContactTokenConfig {
     readonly durationS: number;
@@ -19,6 +21,7 @@ export declare class WaTrustedContactTokenCoordinator {
     private readonly logger;
     private readonly store;
     private readonly runtime;
+    private readonly serverClock;
     private readonly baseConfig;
     private readonly getConfigOverrides;
     private readonly csTokenGenerator;
@@ -29,6 +32,7 @@ export declare class WaTrustedContactTokenCoordinator {
         readonly logger: Logger;
         readonly store: WaPrivacyTokenStore;
         readonly runtime: WaTrustedContactTokenRuntime;
+        readonly serverClock: ServerClock;
         readonly durationS?: number;
         readonly numBuckets?: number;
         readonly senderDurationS?: number;

package/dist/types/client/events/abprops.d.ts

@@ -1,5 +1,5 @@
 import type { BinaryNode } from '../../transport/types';
-export interface AbPropResponseEntry {
+interface AbPropResponseEntry {
     readonly configCode: number;
     readonly configValue: string | null;
 }
@@ -12,3 +12,4 @@ export interface AbPropSyncResult {
     readonly props: readonly AbPropResponseEntry[];
 }
 export declare function parseAbPropsIqResult(node: BinaryNode): AbPropSyncResult;
+export {};

package/dist/types/client/events/appstate-mutation.d.ts

@@ -0,0 +1,3 @@
+import type { WaAppStateMutation } from '../../appstate/types';
+import type { WaAppStateMutationEvent } from '../types';
+export declare function parseAppStateMutationEvent(mutation: WaAppStateMutation): WaAppStateMutationEvent | null;

package/dist/types/client/events/business.d.ts

@@ -0,0 +1,10 @@
+import type { WaBusinessEvent, WaBusinessProfileResult, WaIncomingUnhandledStanzaEvent, WaVerifiedNameResult } from '../types';
+import type { BinaryNode } from '../../transport/types';
+interface WaParseBusinessNotificationResult {
+    readonly events: readonly WaBusinessEvent[];
+    readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
+}
+export declare function parseVerifiedNameNode(node: BinaryNode): WaVerifiedNameResult | null;
+export declare function parseBusinessProfileNode(node: BinaryNode): WaBusinessProfileResult | null;
+export declare function parseBusinessNotificationEvents(notificationNode: BinaryNode): WaParseBusinessNotificationResult;
+export {};

package/dist/types/client/events/call.d.ts

@@ -0,0 +1,31 @@
+import { type WaCallPayloadTag } from '../../protocol/call';
+import type { BinaryNode } from '../../transport/types';
+export type WaCallType = WaCallPayloadTag | 'unknown';
+export interface WaCallGroupParticipant {
+    /** Primary participant addressing inside the call – typically a LID. */
+    readonly jid: string;
+    readonly userPnJid?: string;
+    readonly username?: string;
+    /** Display name for unregistered guests dialled into the call. */
+    readonly guestName?: string;
+}
+export interface ParsedCall {
+    readonly type: WaCallType;
+    readonly payloadTag?: string;
+    readonly callId?: string;
+    readonly callCreatorJid?: string;
+    readonly senderLidJid?: string;
+    readonly callerPnJid?: string;
+    readonly groupJid?: string;
+    readonly isVideo: boolean;
+    readonly callerUsername?: string;
+    readonly callerCountryCode?: string;
+    readonly callerPushName?: string;
+    readonly peerPlatform?: string;
+    readonly peerAppVersion?: string;
+    readonly timestampSeconds?: number;
+    readonly endTimestampSeconds?: number;
+    readonly silenceReason?: string;
+    readonly groupInfo?: readonly WaCallGroupParticipant[];
+}
+export declare function parseCallNode(node: BinaryNode): ParsedCall;

package/dist/types/client/events/chatstate.d.ts

@@ -0,0 +1,9 @@
+import type { ChatstateMedia, ChatstateState } from '../../transport/node/builders/chatstate';
+import type { BinaryNode } from '../../transport/types';
+interface ParsedChatstate {
+    readonly state: ChatstateState;
+    readonly media?: ChatstateMedia;
+    readonly participantJid?: string;
+}
+export declare function parseChatstateNode(node: BinaryNode): ParsedChatstate | null;
+export {};

package/dist/types/client/events/devices.d.ts

@@ -5,16 +5,17 @@ export declare const DEVICE_NOTIFICATION_ACTIONS: Readonly<{
     readonly UPDATE: "update";
 }>;
 export type DeviceNotificationAction = (typeof DEVICE_NOTIFICATION_ACTIONS)[keyof typeof DEVICE_NOTIFICATION_ACTIONS];
-export interface DeviceNotificationDevice {
+interface DeviceNotificationDevice {
     readonly deviceId: number;
     readonly keyIndex: number | null;
 }
-export interface DeviceNotification {
+interface DeviceNotification {
     readonly action: DeviceNotificationAction;
     readonly stanzaId: string;
     readonly fromJid: string;
-    readonly lid: string | undefined;
-    readonly hash: string | undefined;
+    readonly lid: string | null;
+    readonly hash: string | null;
     readonly devices: readonly DeviceNotificationDevice[];
 }
 export declare function parseDeviceNotification(node: BinaryNode): DeviceNotification | null;
+export {};

package/dist/types/client/{dirty.d.ts → events/dirty.d.ts}

@@ -1,6 +1,6 @@
-import type { WaAuthCredentials } from '../auth/types';
-import type { Logger } from '../infra/log/types';
-import type { BinaryNode } from '../transport/types';
+import type { WaAuthCredentials } from '../../auth/types';
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../../transport/types';
 export interface WaDirtyBit {
     readonly type: string;
     readonly timestamp: number;
@@ -14,6 +14,7 @@ interface WaDirtySyncRuntime {
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly syncAppState: () => Promise<void>;
     readonly generateUsyncSid: () => Promise<string>;
+    readonly newsletterListSubscribed?: () => Promise<unknown>;
 }
 export declare function parseDirtyBits(nodes: readonly BinaryNode[], logger: Logger): readonly WaDirtyBit[];
 export declare function handleDirtyBits(runtime: WaDirtySyncRuntime, dirtyBits: readonly WaDirtyBit[]): Promise<void>;

package/dist/types/client/events/group.d.ts

@@ -1,8 +1,9 @@
 import type { WaGroupEvent, WaGroupEventParticipant, WaIncomingUnhandledStanzaEvent } from '../types';
 import type { BinaryNode } from '../../transport/types';
-export interface WaParseGroupNotificationResult {
+interface WaParseGroupNotificationResult {
     readonly events: readonly WaGroupEvent[];
     readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
 }
 export declare function parseParticipants(node: BinaryNode): readonly WaGroupEventParticipant[];
 export declare function parseGroupNotificationEvents(notificationNode: BinaryNode): WaParseGroupNotificationResult;
+export {};

package/dist/types/client/events/identity.d.ts

@@ -1,5 +1,5 @@
 import type { BinaryNode } from '../../transport/types';
-export interface IdentityChangeNotification {
+interface IdentityChangeNotification {
     readonly fromJid: string;
     readonly stanzaId: string;
     readonly displayName: string | undefined;
@@ -7,3 +7,4 @@ export interface IdentityChangeNotification {
     readonly offline: string | undefined;
 }
 export declare function parseIdentityChangeNotification(node: BinaryNode): IdentityChangeNotification | null;
+export {};

package/dist/types/client/{incoming.d.ts → events/incoming.d.ts}

@@ -1,7 +1,8 @@
-import type { WaAccountTakeoverNoticeEvent, WaGroupEvent, WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaRegistrationCodeEvent } from './types';
-import type { Logger } from '../infra/log/types';
-import type { WaConnectionCode, WaDisconnectReason } from '../protocol/stream';
-import type { BinaryNode } from '../transport/types';
+import type { WaAuthCredentials } from '../../auth/types';
+import type { WaAccountTakeoverNoticeEvent, WaBusinessEvent, WaGroupEvent, WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaMexNotificationEvent, WaPictureEvent, WaRegistrationCodeEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaConnectionCode, WaDisconnectReason } from '../../protocol/stream';
+import type { BinaryNode } from '../../transport/types';
 interface IncomingAckRuntime {
     readonly logger: Logger;
     readonly sendNode: (node: BinaryNode) => Promise<void>;
@@ -20,6 +21,7 @@ type IncomingFailureHandlerOptions = {
 };
 type IncomingNotificationHandlerOptions = IncomingAckRuntime & {
     readonly emitIncomingNotification: (event: WaIncomingNotificationEvent) => void;
+    readonly emitMexNotification: (event: WaMexNotificationEvent) => void;
     readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
     readonly syncAppState?: () => Promise<void>;
 };
@@ -27,16 +29,37 @@ type IncomingGroupNotificationHandlerOptions = IncomingAckRuntime & {
     readonly emitGroupEvent: (event: WaGroupEvent) => void;
     readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
 };
+type IncomingBusinessNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitBusinessEvent: (event: WaBusinessEvent) => void;
+    readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
+};
+type IncomingPictureNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitPictureEvent: (event: WaPictureEvent) => void;
+    readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
+};
 type IncomingRegistrationNotificationHandlerOptions = IncomingAckRuntime & {
     readonly emitRegistrationCode: (event: WaRegistrationCodeEvent) => void;
     readonly emitAccountTakeoverNotice: (event: WaAccountTakeoverNoticeEvent) => void;
 };
+type IncomingCallHandlerOptions = IncomingAckRuntime & {
+    readonly emitIncomingCall: (event: WaIncomingCallEvent) => void;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
+};
+/**
+ * Builds the inbound ack for `message`/`receipt`/`notification` tags. Returns
+ * `null` for other tags or when required attrs are missing.
+ */
+export declare function buildInboundAck(node: BinaryNode): BinaryNode | null;
 export declare function createIncomingBaseEvent(node: BinaryNode): WaIncomingBaseEvent;
+export declare function sendSafeAck(logger: Logger, sendNode: (node: BinaryNode) => Promise<void>, node: BinaryNode): Promise<void>;
 export declare function createIncomingReceiptHandler(options: IncomingReceiptHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingFailureHandler(options: IncomingFailureHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingNotificationHandler(options: IncomingNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingRegistrationNotificationHandler(options: IncomingRegistrationNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingBusinessNotificationHandler(options: IncomingBusinessNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingGroupNotificationHandler(options: IncomingGroupNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingPictureNotificationHandler(options: IncomingPictureNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingCallHandler(options: IncomingCallHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createInfoBulletinNotificationEvent(node: BinaryNode, type: string, details?: Readonly<Record<string, unknown>>): WaIncomingNotificationEvent;
 export declare function createUnhandledIncomingNodeEvent(node: BinaryNode, reason?: string): WaIncomingUnhandledStanzaEvent;
 export {};

package/dist/types/client/events/mex-notification.d.ts

@@ -0,0 +1,6 @@
+import type { WaIncomingBaseEvent, WaMexNotificationEvent } from '../types';
+import type { BinaryNode } from '../../transport/types';
+type DistributiveOmit<T, K extends keyof never> = T extends unknown ? Omit<T, K> : never;
+export type WaMexNotificationParsed = DistributiveOmit<WaMexNotificationEvent, keyof WaIncomingBaseEvent>;
+export declare function parseMexNotification(node: BinaryNode): WaMexNotificationParsed | null;
+export {};

package/dist/types/client/events/picture.d.ts

@@ -0,0 +1,8 @@
+import type { WaIncomingUnhandledStanzaEvent, WaPictureEvent } from '../types';
+import type { BinaryNode } from '../../transport/types';
+interface WaParsePictureNotificationResult {
+    readonly events: readonly WaPictureEvent[];
+    readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
+}
+export declare function parsePictureNotificationEvents(node: BinaryNode): WaParsePictureNotificationResult;
+export {};

package/dist/types/client/events/presence.d.ts

@@ -0,0 +1,28 @@
+import { WA_PRESENCE_TYPES } from '../../protocol/presence';
+import type { BinaryNode } from '../../transport/types';
+export type IncomingPresenceType = typeof WA_PRESENCE_TYPES.AVAILABLE | typeof WA_PRESENCE_TYPES.UNAVAILABLE;
+export type PresenceLastSeen = 
+/** Numeric `last` attr the peer disclosed. */
+{
+    readonly kind: 'timestamp';
+    readonly unixSeconds: number;
+}
+/** Peer's privacy settings hide last-seen from this account (WA `deny` sentinel). */
+ | {
+    readonly kind: 'privacy_denied';
+}
+/** Peer has never been online since the contact was added (WA `none` sentinel). */
+ | {
+    readonly kind: 'never_online';
+}
+/** WA `error` sentinel or an unparseable `last` value. */
+ | {
+    readonly kind: 'unknown';
+};
+interface ParsedPresence {
+    readonly type: IncomingPresenceType;
+    readonly lastSeen?: PresenceLastSeen;
+    readonly groupOnlineCount?: number;
+}
+export declare function parsePresenceNode(node: BinaryNode): ParsedPresence;
+export {};

package/dist/types/client/events/receipt.d.ts

@@ -0,0 +1,14 @@
+interface ReceiptTarget {
+    readonly chatJid: string;
+    readonly id: string;
+    readonly senderJid?: string;
+    readonly isGroupChat?: boolean;
+    readonly isBroadcastChat?: boolean;
+}
+interface AggregatedReceiptGroup {
+    readonly jid: string;
+    readonly ids: readonly string[];
+    readonly participant?: string;
+}
+export declare function aggregateReceiptTargets(targets: readonly ReceiptTarget[]): readonly AggregatedReceiptGroup[];
+export {};

package/dist/types/client/events/registration.d.ts

@@ -1,11 +1,11 @@
 import type { BinaryNode } from '../../transport/types';
-export interface ParsedRegistrationCode {
+interface ParsedRegistrationCode {
     readonly kind: 'registration_code';
     readonly code: string;
     readonly expiryTimestampMs: number;
     readonly fromDeviceId: string;
 }
-export interface ParsedAccountTakeoverNotice {
+interface ParsedAccountTakeoverNotice {
     readonly kind: 'account_takeover_notice';
     readonly serverToken: string;
     readonly attemptTimestampMs: number;
@@ -13,5 +13,6 @@ export interface ParsedAccountTakeoverNotice {
     readonly newDevicePlatform?: string;
     readonly newDeviceAppVersion?: string;
 }
-export type ParsedRegistrationNotification = ParsedRegistrationCode | ParsedAccountTakeoverNotice | null;
+type ParsedRegistrationNotification = ParsedRegistrationCode | ParsedAccountTakeoverNotice | null;
 export declare function parseRegistrationNotification(node: BinaryNode): ParsedRegistrationNotification;
+export {};

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

@@ -1,2 +1,2 @@
 export { WaClient } from './WaClient';
-export type { WaAppStateMessageKey, WaClientProxyOptions, WaClearChatOptions, WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaConnectionEvent, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaLogoutStoreClearOptions, WaWriteBehindOptions } from './types';
+export type { WaAppStateMessageKey, WaAppStateMutationEvent, WaAppStateMutationSource, WaClearChatOptions, WaConnectionEvent, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaLogoutStoreClearOptions } from './types';

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

@@ -1,6 +1,8 @@
-import type { Readable } from 'node:stream';
+import { type Readable } from 'node:stream';
 import type { WaMediaOptions } from './types';
 import type { Logger } from '../infra/log/types';
+import type { WaMediaTransferClient } from '../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../media/types';
 import type { WaSendMediaMessage } from '../message/types';
 export interface ProcessedMediaFields {
     readonly jpegThumbnail?: Uint8Array;
@@ -20,12 +22,44 @@ interface WebpAnimInfo {
 export declare function parseWebpAnimation(data: Uint8Array): WebpAnimInfo | null;
 export declare function isReadableStream(value: unknown): value is Readable;
 export declare function cleanupTempFile(filePath: string): Promise<void>;
+export interface StreamFileMetrics {
+    readonly fileSha256: Uint8Array;
+    readonly byteLength: number;
+}
+export type WaUploadMediaSource = Uint8Array | string | Readable;
+export declare function selectMediaUploadHost(mediaConn: WaMediaConn): string;
+export declare function buildMediaUploadUrl(host: string, path: string, auth: string, fileSha256: Uint8Array, mediaId?: string): string;
+export declare function assertMediaUploadStatus(status: number, label: string): void;
+export declare function parseMediaUploadJsonBody<T>(body: Uint8Array, label: string): T;
+export interface PlaintextMediaUploadDeps {
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly mediaConn: WaMediaConn;
+    readonly logger: Logger;
+}
+export interface PlaintextMediaUploadInput {
+    readonly source: WaUploadMediaSource;
+    readonly path: string;
+    readonly mimetype?: string;
+    readonly logLabel?: string;
+}
+export interface PlaintextMediaUploadResult {
+    readonly responseBytes: Uint8Array;
+    readonly status: number;
+    readonly fileSha256: Uint8Array;
+    readonly byteLength: number;
+    readonly mediaId: string;
+}
+export declare function performPlaintextMediaUpload(deps: PlaintextMediaUploadDeps, input: PlaintextMediaUploadInput): Promise<PlaintextMediaUploadResult>;
 export interface ResolvedMediaInputs {
     readonly processorInput?: Uint8Array | string;
     readonly uploadMedia: Uint8Array | Readable;
     readonly tempFilePath?: string;
 }
 export declare function resolveMediaInputs(shouldProcess: boolean, raw: Uint8Array | ArrayBuffer | Readable | string): Promise<ResolvedMediaInputs>;
+export declare function shouldNormalizeVoiceNote(media: WaMediaOptions | undefined, content: WaSendMediaMessage): content is WaSendMediaMessage & {
+    type: 'audio';
+};
 export declare function hasMediaProcessingTasks(media: WaMediaOptions | undefined, content: WaSendMediaMessage): boolean;
+export declare function getScopedMediaLogger(parent: Logger): Logger;
 export declare function runMediaProcessor(media: WaMediaOptions | undefined, input: Uint8Array | string | undefined, content: WaSendMediaMessage, logger: Logger): Promise<ProcessedMediaFields>;
 export {};

package/dist/types/client/messaging/fanout.d.ts

@@ -1,3 +1,4 @@
+import type { WaAuthCredentials } from '../../auth/types';
 import type { Logger } from '../../infra/log/types';
 import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
 export type DeviceFanoutResolver = {
@@ -8,7 +9,6 @@ export type DeviceFanoutResolver = {
 };
 export declare function createDeviceFanoutResolver(options: {
     readonly signalDeviceSync: SignalDeviceSyncApi;
-    readonly getCurrentMeJid: () => string | null | undefined;
-    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly logger: Logger;
 }): DeviceFanoutResolver;

package/dist/types/client/messaging/group-metadata.d.ts

@@ -0,0 +1,19 @@
+import type { WaGroupEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaGroupMetadataStore } from '../../store/contracts/group-metadata.store';
+export type GroupMetadataQueryResult = {
+    readonly participants: readonly string[];
+    readonly ephemeral?: number;
+};
+export type GroupMetadataCache = {
+    resolveParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    refreshParticipantUsers(groupJid: string): Promise<readonly string[]>;
+    getEphemeral(groupJid: string): Promise<number | null>;
+    resolveEphemeral(groupJid: string): Promise<number | null>;
+    mutateFromGroupEvent(event: WaGroupEvent): Promise<void>;
+};
+export declare function createGroupMetadataCache(options: {
+    readonly groupMetadataStore: WaGroupMetadataStore;
+    readonly queryGroupMetadata: (groupJid: string) => Promise<GroupMetadataQueryResult>;
+    readonly logger: Logger;
+}): GroupMetadataCache;

package/dist/types/client/messaging/ignore-key.d.ts

@@ -0,0 +1,11 @@
+import type { WaIgnoreKey, WaIgnoreKeyContext, WaIgnoreKeyPredicate, WaIncomingStanzaFilter } from '../types';
+import type { BinaryNode } from '../../transport/types';
+export declare function validateIgnoreKey(d: WaIgnoreKey): void;
+/**
+ * Builds the parsed context handed to a {@link WaIgnoreKeyPredicate}. Returns
+ * `null` when the node's tag is not one of the addressable kinds (`<iq>`, etc.).
+ */
+export declare function extractIgnoreKeyContext(node: BinaryNode, meJid: string | null | undefined): WaIgnoreKeyContext | null;
+/** Pure matcher. Exported for direct testing without a coordinator. */
+export declare function matchesIgnoreKey(node: BinaryNode, d: WaIgnoreKey, meJid: string | null | undefined): boolean;
+export declare function createIgnoreKeyFilter(input: WaIgnoreKey | WaIgnoreKeyPredicate, getMeJid: () => string | null | undefined): WaIncomingStanzaFilter;

package/dist/types/client/messaging/key-protocol.d.ts

@@ -1,18 +1,20 @@
 import type { WaAppStateSyncKey } from '../../appstate/types';
+import type { WaAuthCredentials } from '../../auth/types';
 import type { DeviceFanoutResolver } from '../messaging/fanout';
-import type { WaSignalMessagePublishInput } from '../types';
 import type { Logger } from '../../infra/log/types';
-import type { WaMessagePublishOptions, WaMessagePublishResult } from '../../message/types';
-type PublishSignalMessageFn = (input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions) => Promise<WaMessagePublishResult>;
+import type { WaMessagePublishResult } from '../../message/types';
+import { type Proto } from '../../proto';
+export type PublishProtocolMessageToDeviceFn = (deviceJid: string, protocolMessage: Proto.Message.IProtocolMessage, options?: {
+    readonly id?: string;
+    readonly pushPriority?: 'high' | 'high_force';
+}) => Promise<WaMessagePublishResult>;
 export type AppStateSyncKeyProtocol = {
     requestKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
     sendKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
 };
 export declare function createAppStateSyncKeyProtocol(options: {
-    readonly publishSignalMessage: PublishSignalMessageFn;
+    readonly publishProtocolMessageToDevice: PublishProtocolMessageToDeviceFn;
     readonly fanoutResolver: DeviceFanoutResolver;
-    readonly getCurrentMeJid: () => string | null | undefined;
-    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly logger: Logger;
 }): AppStateSyncKeyProtocol;
-export {};

package/dist/types/client/messaging/link-preview.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../../media/types';
+import type { WaLinkPreviewThumbnailFields } from '../../message/addons/link-preview/builder';
+import type { WaLinkPreviewFetcher, WaLinkPreviewOptions, WaLinkPreviewOverride, WaLinkPreviewResolved } from '../../message/addons/link-preview/types';
+import type { ServerClock } from '../../util/clock';
+export interface ResolveLinkPreviewDeps {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly getMediaConn: () => Promise<WaMediaConn>;
+    readonly fetcher: WaLinkPreviewFetcher;
+    readonly options: WaLinkPreviewOptions;
+    readonly serverClock: ServerClock;
+}
+export interface ResolvedLinkPreviewResult {
+    readonly resolved: WaLinkPreviewResolved;
+    readonly thumbnailFields: WaLinkPreviewThumbnailFields;
+}
+export declare function resolveLinkPreview(text: string, perMessage: boolean | WaLinkPreviewOverride | undefined, deps: ResolveLinkPreviewDeps): Promise<ResolvedLinkPreviewResult | null>;

package/dist/types/client/messaging/messages.d.ts

@@ -0,0 +1,28 @@
+import type { ResolvedLinkPreviewResult } from '../messaging/link-preview';
+import type { WaMediaOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../../media/types';
+import type { WaMessageBuildResult, WaSendMessageContent, WaSendTextMessage } from '../../message/types';
+import type { BinaryNode } from '../../transport/types';
+import type { ServerClock } from '../../util/clock';
+export interface WaMediaMessageOptions {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly iqTimeoutMs?: number;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly getMediaConnCache: () => WaMediaConn | null;
+    readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
+    readonly serverClock: ServerClock;
+    readonly media?: WaMediaOptions;
+    readonly linkPreviewResolver?: (content: WaSendTextMessage) => Promise<ResolvedLinkPreviewResult | null>;
+}
+export interface WaBuildMessageContext {
+    readonly to: string;
+    /** Outgoing stanza id, pre-resolved. Required for addon-crypto kinds (poll-vote, event-response). */
+    readonly outgoingStanzaId?: string;
+    /** Current me jid (used as modificationSender for addon crypto). */
+    readonly meJid?: string;
+}
+export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent, ctx?: WaBuildMessageContext): Promise<WaMessageBuildResult>;
+export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;