zapo-js 0.3.0 → 1.0.1

package/dist/types/client/newsletter/admin.d.ts

@@ -0,0 +1,71 @@
+import { type WaNewsletterMexDeps } from '../newsletter/mex';
+import type { WaNewsletterAdminInfo, WaNewsletterAdminInviteInput, WaNewsletterAdminInviteResult, WaNewsletterCapability, WaNewsletterCapabilityExposure, WaNewsletterCreateInput, WaNewsletterFollowersOptions, WaNewsletterFollowersPage, WaNewsletterInsightMetricRequest, WaNewsletterMetadata, WaNewsletterPollVoter, WaNewsletterReactionSenders, WaNewsletterUpdateInput } from '../newsletter/types';
+import type { WaMexOperationResponses } from '../../mex';
+import { type WaTosQueryResult } from '../../transport/node/builders/tos';
+/** Admin-side newsletter operations (create/update/delete + insights). */
+export interface WaNewsletterAdminOps {
+    /**
+     * Creates a new newsletter the current account will own. **Auto-accepts
+     * the newsletter-creation TOS** before issuing the create IQ (no manual
+     * {@link acceptTos} call needed). `input.picture` is uploaded as JPEG
+     * bytes inline (not via the media transfer path) - keep it small.
+     */
+    readonly create: (input: WaNewsletterCreateInput) => Promise<WaNewsletterMetadata>;
+    /** Updates the newsletter's editable fields (name/description/picture). */
+    readonly update: (newsletterJid: string, input: WaNewsletterUpdateInput) => Promise<WaNewsletterMetadata>;
+    /**
+     * Permanently deletes the newsletter. **Irreversible** - followers are
+     * detached, message history is dropped server-side, and the JID is
+     * burned (you can't re-create with the same name and recover anything).
+     */
+    readonly delete: (newsletterJid: string) => Promise<void>;
+    /** Returns the admin-only metadata view for the newsletter. */
+    readonly fetchAdminInfo: (newsletterJid: string) => Promise<WaNewsletterAdminInfo>;
+    /** Returns the set of admin capabilities currently granted to the account. */
+    readonly fetchAdminCapabilities: (newsletterJid: string) => Promise<ReadonlySet<WaNewsletterCapability>>;
+    /** Lists newsletter followers (paged). */
+    readonly fetchFollowers: (newsletterJid: string, options?: WaNewsletterFollowersOptions) => Promise<WaNewsletterFollowersPage>;
+    /** Fetches admin analytics for the requested metric set. */
+    readonly fetchInsights: (newsletterJid: string, metrics: readonly WaNewsletterInsightMetricRequest[]) => Promise<WaMexOperationResponses['FetchNewsletterInsights'] | null>;
+    /** Fetches the moderation reports raised against owned newsletters. */
+    readonly fetchReports: () => Promise<WaMexOperationResponses['FetchNewsletterReports'] | null>;
+    /** Returns JIDs of pending admin invites for the newsletter. */
+    readonly fetchPendingInvites: (newsletterJid: string) => Promise<readonly string[]>;
+    /** Fetches any moderation enforcement state applied to the newsletter. */
+    readonly fetchEnforcements: (newsletterJid: string) => Promise<WaMexOperationResponses['FetchNewsletterEnforcements'] | null>;
+    /** Lists voters of a newsletter poll, grouped by selected option. */
+    readonly fetchPollVoters: (input: {
+        readonly newsletterJid: string;
+        readonly messageServerId: number;
+        readonly voteHash: string;
+        readonly limit?: number;
+    }) => Promise<ReadonlyMap<string, readonly WaNewsletterPollVoter[]>>;
+    /** Lists reaction senders for a newsletter message, grouped by emoji. */
+    readonly fetchMessageReactionSenders: (input: {
+        readonly newsletterJid: string;
+        readonly messageServerId: number;
+    }) => Promise<readonly WaNewsletterReactionSenders[]>;
+    /** Reports newsletter capability exposures back to the server for telemetry. */
+    readonly logExposures: (exposures: readonly WaNewsletterCapabilityExposure[]) => Promise<void>;
+    /** Transfers newsletter ownership to a previously-invited admin. */
+    readonly changeOwner: (input: WaNewsletterAdminInviteInput) => Promise<void>;
+    /** Demotes an admin back to a regular follower. */
+    readonly demoteAdmin: (input: WaNewsletterAdminInviteInput) => Promise<void>;
+    /** Sends an admin invite to a user; returns the invite envelope/expiry. */
+    readonly createAdminInvite: (input: WaNewsletterAdminInviteInput) => Promise<WaNewsletterAdminInviteResult>;
+    /**
+     * Accepts a pending admin invite on the current account.
+     * **Auto-accepts the admin-invite TOS** before the accept IQ.
+     * Throws when no invite exists or it has been revoked / expired -
+     * check {@link fetchPendingInvites} from the inviter side first.
+     */
+    readonly acceptAdminInvite: (newsletterJid: string) => Promise<void>;
+    /** Revokes a previously-sent admin invite. */
+    readonly revokeAdminInvite: (input: WaNewsletterAdminInviteInput) => Promise<void>;
+    /** Returns the TOS acceptance state for the given notice ids. */
+    readonly queryTosState: (noticeIds: readonly string[]) => Promise<WaTosQueryResult>;
+    /** Accepts the given TOS notice ids on behalf of the current account. */
+    readonly acceptTos: (noticeIds: readonly string[]) => Promise<void>;
+}
+/** Builds the admin operation set. */
+export declare function createAdminOps(deps: WaNewsletterMexDeps): WaNewsletterAdminOps;

package/dist/types/client/newsletter/content.d.ts

@@ -0,0 +1,42 @@
+import { type WaUploadMediaSource } from '../media';
+import type { Logger } from '../../infra/log/types';
+import { type NewsletterMediaKind } from '../../media/constants';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../../media/types';
+import { type WaSendContextInfo } from '../../message/context-info';
+import type { WaSendMessageContent } from '../../message/types';
+export type WaNewsletterUploadMedia = WaUploadMediaSource;
+export interface WaNewsletterUploadInput {
+    readonly mediaKind: NewsletterMediaKind;
+    readonly media: WaNewsletterUploadMedia;
+    readonly mimetype: string;
+    readonly mediaConn: WaMediaConn;
+}
+export interface WaNewsletterUploadResult {
+    readonly url: string;
+    readonly directPath: string;
+    readonly handle?: string;
+    readonly metadataUrl?: string;
+    readonly thumbnailDirectPath?: string;
+    readonly thumbnailSha256?: Uint8Array;
+    readonly fileSha256: Uint8Array;
+    readonly fileLength: number;
+    readonly mediaId: string;
+}
+export declare function uploadNewsletterMedia(options: {
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly logger: Logger;
+}, input: WaNewsletterUploadInput): Promise<WaNewsletterUploadResult>;
+export type WaNewsletterContentKind = 'text' | 'media' | 'poll-creation';
+export interface WaNewsletterBuiltContent {
+    readonly kind: WaNewsletterContentKind;
+    readonly plaintext: Uint8Array;
+    readonly mediaType: string | null;
+    readonly upload: WaNewsletterUploadResult | null;
+}
+export interface BuildNewsletterContentOptions {
+    readonly logger: Logger;
+    readonly mediaTransfer?: WaMediaTransferClient;
+    readonly getMediaConn?: () => Promise<WaMediaConn>;
+}
+export declare function buildNewsletterMessageContent(options: BuildNewsletterContentOptions, content: WaSendMessageContent, ctx?: WaSendContextInfo | null): Promise<WaNewsletterBuiltContent>;

package/dist/types/client/newsletter/discovery.d.ts

@@ -0,0 +1,33 @@
+import { type WaNewsletterMexDeps } from '../newsletter/mex';
+import type { WaNewsletterDehydratedMetadata, WaNewsletterDirectoryCategoriesPreviewOptions, WaNewsletterDirectoryCategoryPreview, WaNewsletterDirectoryListOptions, WaNewsletterDirectoryResults, WaNewsletterDirectorySearchOptions, WaNewsletterFetchOptions, WaNewsletterMetadata, WaNewsletterRecommendedOptions, WaNewsletterSimilarOptions } from '../newsletter/types';
+import { WA_NEWSLETTER_VIEW_ROLES } from '../../protocol/newsletter';
+/** Discovery-side newsletter operations (lookup, search, recommendations). */
+export interface WaNewsletterDiscoveryOps {
+    /** Fetches the full metadata for a newsletter by JID. */
+    readonly fetch: (newsletterJid: string, options?: WaNewsletterFetchOptions) => Promise<WaNewsletterMetadata>;
+    /** Fetches the full metadata for a newsletter by invite code. */
+    readonly fetchByInvite: (inviteCode: string, options?: WaNewsletterFetchOptions) => Promise<WaNewsletterMetadata>;
+    /** Lists newsletters the current account is subscribed to. */
+    readonly listSubscribed: (options?: {
+        readonly fetchWamoSub?: boolean;
+    }) => Promise<readonly WaNewsletterMetadata[]>;
+    /** Searches the public newsletter directory by text/categories. */
+    readonly searchDirectory: (options?: WaNewsletterDirectorySearchOptions) => Promise<WaNewsletterDirectoryResults>;
+    /** Lists newsletters recommended for the current account. */
+    readonly fetchRecommended: (options?: WaNewsletterRecommendedOptions) => Promise<readonly WaNewsletterMetadata[]>;
+    /** Lists newsletters similar to `newsletterJid`. */
+    readonly fetchSimilar: (newsletterJid: string, options?: WaNewsletterSimilarOptions) => Promise<readonly WaNewsletterMetadata[]>;
+    /** Paged directory listing scoped by country/category. */
+    readonly fetchDirectoryList: (options: WaNewsletterDirectoryListOptions) => Promise<WaNewsletterDirectoryResults>;
+    /** Preview cards for the directory categories carousel. */
+    readonly fetchDirectoryCategoriesPreview: (options: WaNewsletterDirectoryCategoriesPreviewOptions) => Promise<readonly WaNewsletterDirectoryCategoryPreview[]>;
+    /** Resolves which of the given URL domains support link previews. */
+    readonly fetchIsDomainPreviewable: (domains: readonly string[]) => Promise<ReadonlyMap<string, boolean>>;
+    /** Lightweight metadata fetch (no full image / followers). */
+    readonly fetchDehydrated: (keyOrInvite: string, options?: {
+        readonly viewRole?: keyof typeof WA_NEWSLETTER_VIEW_ROLES;
+        readonly fetchWamoSub?: boolean;
+    }) => Promise<WaNewsletterDehydratedMetadata>;
+}
+/** Builds the discovery operation set. */
+export declare function createDiscoveryOps(deps: WaNewsletterMexDeps): WaNewsletterDiscoveryOps;

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

@@ -0,0 +1,66 @@
+import { type WaNewsletterMexDeps } from '../newsletter/mex';
+import type { WaNewsletterMuteInput, WaNewsletterReactInput, WaNewsletterRevokeInput, WaNewsletterSendOptions, WaNewsletterSendResult, WaNewsletterViewReceiptInput, WaNewsletterVotePollInput } from '../newsletter/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import type { WaMediaConn } from '../../media/types';
+import type { WaMessagePublishOptions, WaMessagePublishResult, WaSendMessageContent } from '../../message/types';
+import type { BinaryNode } from '../../transport/types';
+export interface WaNewsletterMessagingDeps extends WaNewsletterMexDeps {
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly publishMessageNode: (node: BinaryNode, options?: WaMessagePublishOptions) => Promise<WaMessagePublishResult>;
+    readonly generateStanzaId: () => Promise<string>;
+    readonly mediaTransfer?: WaMediaTransferClient;
+    readonly getMediaConn?: () => Promise<WaMediaConn>;
+}
+/** Newsletter messaging operations (send, react, fetch, follow). */
+export interface WaNewsletterMessagingOps {
+    /** Publishes a message to the newsletter. */
+    readonly send: (newsletterJid: string, content: WaSendMessageContent, options?: WaNewsletterSendOptions) => Promise<WaNewsletterSendResult>;
+    /** Edits a previously-published newsletter message. */
+    readonly editMessage: (newsletterJid: string, parentMessageId: string, content: WaSendMessageContent) => Promise<WaNewsletterSendResult>;
+    /** Reacts (or clears the reaction) on a newsletter message. */
+    readonly react: (input: WaNewsletterReactInput) => Promise<{
+        readonly stanzaId: string;
+    }>;
+    /** Revokes a previously-published newsletter message. */
+    readonly revoke: (input: WaNewsletterRevokeInput) => Promise<{
+        readonly stanzaId: string;
+    }>;
+    /** Casts a vote on a newsletter poll. */
+    readonly votePoll: (input: WaNewsletterVotePollInput) => Promise<{
+        readonly stanzaId: string;
+    }>;
+    /** Sends a view-receipt notification for a newsletter message. */
+    readonly sendViewReceipt: (input: WaNewsletterViewReceiptInput) => Promise<{
+        readonly stanzaId: string;
+    }>;
+    /** Fetches a page of newsletter messages. */
+    readonly fetchMessages: (input: {
+        readonly newsletterJid: string;
+        readonly count: number;
+        readonly before?: number;
+        readonly after?: number;
+        readonly viewRole?: string;
+    }) => Promise<BinaryNode>;
+    /** Fetches edits/reactions/poll updates for newsletter messages in a range. */
+    readonly fetchMessageUpdates: (input: {
+        readonly newsletterJid: string;
+        readonly count: number;
+        readonly since?: number;
+        readonly before?: number;
+        readonly after?: number;
+    }) => Promise<BinaryNode>;
+    /**
+     * Subscribes to live updates for the newsletter and returns the
+     * server-granted subscription duration.
+     */
+    readonly subscribeLiveUpdates: (newsletterJid: string) => Promise<{
+        readonly durationSeconds: number;
+    }>;
+    /** Follows the newsletter on the current account. */
+    readonly follow: (newsletterJid: string) => Promise<void>;
+    /** Unfollows the newsletter on the current account. */
+    readonly unfollow: (newsletterJid: string) => Promise<void>;
+    /** Mutes or unmutes the newsletter (per {@link WaNewsletterMuteInput}). */
+    readonly mute: (input: WaNewsletterMuteInput) => Promise<void>;
+}
+export declare function createMessagingOps(deps: WaNewsletterMessagingDeps): WaNewsletterMessagingOps;

package/dist/types/client/newsletter/mex.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaMexOperationResponses, WaMexOperationVariables } from '../../mex';
+import type { AbPropName } from '../../protocol/abprops';
+import { type WaMexOpKey, type WaMexQuerySocket } from '../../transport/node/mex/client';
+import type { BinaryNode } from '../../transport/types';
+export type WaNewsletterTosKind = 'creation' | 'consumer' | 'admin_invite';
+export interface WaNewsletterMexDeps {
+    readonly mexSocket: WaMexQuerySocket;
+    readonly queryWithContext?: (context: string, node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    readonly getAbPropString?: (name: AbPropName) => string;
+    readonly logger: Logger;
+}
+export declare function runMex<K extends WaMexOpKey>(deps: WaNewsletterMexDeps, opKey: K, variables: WaMexOperationVariables[K]): Promise<WaMexOperationResponses[K] | null>;
+export declare function ensureTosAccepted(deps: WaNewsletterMexDeps, kind: WaNewsletterTosKind): Promise<void>;

package/dist/types/client/newsletter/parse.d.ts

@@ -0,0 +1,19 @@
+import type { WaNewsletterAdminInfo, WaNewsletterAdminInviteResult, WaNewsletterCapability, WaNewsletterDehydratedMetadata, WaNewsletterDirectoryCategoryPreview, WaNewsletterDirectoryResults, WaNewsletterFollowersPage, WaNewsletterMetadata, WaNewsletterPollVoter, WaNewsletterReactionSenders } from '../newsletter/types';
+import type { WaMexOperationResponses } from '../../mex';
+type WaNewsletterMetadataEnvelope = NonNullable<WaMexOperationResponses['FetchNewsletter']['xwa2_newsletter']>;
+export declare function parseNewsletterMetadata(envelope: WaNewsletterMetadataEnvelope | null | undefined): WaNewsletterMetadata;
+export declare function parseAdminInfo(data: WaMexOperationResponses['FetchNewsletterAdminInfo'] | null): WaNewsletterAdminInfo;
+export declare function parseAdminCapabilities(data: WaMexOperationResponses['FetchNewsletterAdminCapabilities'] | null): ReadonlySet<WaNewsletterCapability>;
+export declare function parsePendingInvites(data: WaMexOperationResponses['FetchNewsletterPendingInvites'] | null): readonly string[];
+export declare function parseFollowers(data: WaMexOperationResponses['FetchNewsletterFollowers'] | null): WaNewsletterFollowersPage;
+export declare function parseDirectorySearch(data: WaMexOperationResponses['FetchNewsletterDirectorySearchResults'] | null): WaNewsletterDirectoryResults;
+export declare function parseDirectoryList(data: WaMexOperationResponses['FetchNewsletterDirectoryList'] | null): WaNewsletterDirectoryResults;
+export declare function parseRecommended(data: WaMexOperationResponses['FetchRecommendedNewsletters'] | null): readonly WaNewsletterMetadata[];
+export declare function parseSimilar(data: WaMexOperationResponses['FetchSimilarNewsletters'] | null): readonly WaNewsletterMetadata[];
+export declare function parseDomainsPreviewable(data: WaMexOperationResponses['FetchNewsletterIsDomainPreviewable'] | null): ReadonlyMap<string, boolean>;
+export declare function parseDirectoryCategoriesPreview(data: WaMexOperationResponses['FetchNewsletterDirectoryCategoriesPreview'] | null): readonly WaNewsletterDirectoryCategoryPreview[];
+export declare function parseDehydratedMetadata(data: WaMexOperationResponses['FetchNewsletterDehydrated'] | null): WaNewsletterDehydratedMetadata;
+export declare function parseAdminInviteResult(data: WaMexOperationResponses['CreateNewsletterAdminInvite'] | null): WaNewsletterAdminInviteResult;
+export declare function parseReactionSenders(data: WaMexOperationResponses['FetchNewsletterMessageReactionSenderList'] | null): readonly WaNewsletterReactionSenders[];
+export declare function parsePollVoters(data: WaMexOperationResponses['FetchNewsletterPollVoters'] | null): ReadonlyMap<string, readonly WaNewsletterPollVoter[]>;
+export {};

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

@@ -0,0 +1,190 @@
+import type { WaSendContextInfo } from '../../message/context-info';
+import type { WaMessagePublishResult } from '../../message/types';
+import type { WaMexOperationResponses } from '../../mex';
+import type { WA_NEWSLETTER_VIEW_ROLES, WaNewsletterRole, WaNewsletterStateType } from '../../protocol/newsletter';
+export type WaNewsletterCapability = NonNullable<NonNullable<WaMexOperationResponses['FetchNewsletterAdminCapabilities']['xwa2_newsletter_admin']>['capabilities']>[number];
+export interface WaNewsletterPicture {
+    readonly url?: string;
+    readonly directPath?: string;
+    readonly id?: string;
+}
+export interface WaNewsletterMetadata {
+    readonly jid: string;
+    readonly state: WaNewsletterStateType;
+    readonly creationTime?: number;
+    readonly name?: string;
+    readonly nameUpdateTime?: number;
+    readonly description?: string;
+    readonly descriptionUpdateTime?: number;
+    readonly picture?: WaNewsletterPicture;
+    readonly preview?: WaNewsletterPicture;
+    readonly invite?: string;
+    readonly handle?: string;
+    readonly subscribersCount?: number;
+    readonly verification?: string;
+    readonly viewerRole?: WaNewsletterRole;
+    readonly mutedAdmin?: boolean;
+    readonly mutedFollower?: boolean;
+}
+export interface WaNewsletterFetchOptions {
+    readonly fetchViewerMetadata?: boolean;
+    readonly fetchCreationTime?: boolean;
+    readonly fetchFullImage?: boolean;
+    readonly fetchWamoSub?: boolean;
+    readonly viewRole?: keyof typeof WA_NEWSLETTER_VIEW_ROLES;
+}
+export interface WaNewsletterInsightMetricRequest {
+    readonly id: number;
+    readonly type: string;
+    readonly group_by?: {
+        readonly number_of_days?: number;
+    };
+}
+export interface WaNewsletterDirectorySearchOptions {
+    readonly searchText?: string;
+    readonly startCursor?: string;
+    readonly limit?: number;
+    readonly categories?: readonly string[];
+}
+export type WaNewsletterDirectoryView = 'RECOMMENDED' | 'NEW' | 'POPULAR' | 'FEATURED' | 'TRENDING';
+export interface WaNewsletterDirectoryListOptions {
+    readonly view: WaNewsletterDirectoryView;
+    readonly countryCodes?: readonly string[];
+    readonly categories?: readonly string[];
+    readonly startCursor?: string;
+    readonly limit?: number;
+}
+export interface WaNewsletterRecommendedOptions {
+    readonly limit?: number;
+    readonly countryCodes?: readonly string[];
+}
+export interface WaNewsletterSimilarOptions {
+    readonly limit?: number;
+    readonly countryCodes?: readonly string[];
+}
+export interface WaNewsletterFollowersOptions {
+    readonly count?: number;
+}
+export interface WaNewsletterDirectoryCategoriesPreviewOptions {
+    readonly categories: readonly string[];
+    readonly countryCode?: string;
+    readonly perCategoryLimit?: number;
+}
+export interface WaNewsletterCapabilityExposure {
+    readonly newsletterJid: string;
+    readonly capability: WaNewsletterCapability;
+}
+export interface WaNewsletterCreateInput {
+    readonly name: string;
+    readonly description?: string;
+    readonly picture?: Uint8Array;
+}
+export interface WaNewsletterUpdateInput {
+    readonly name?: string;
+    readonly description?: string;
+    readonly picture?: Uint8Array | null;
+    readonly reactionCodesSetting?: string;
+}
+export interface WaNewsletterMuteInput {
+    readonly newsletterJid: string;
+    readonly mute: boolean;
+    readonly type?: 'admin' | 'follower';
+}
+export interface WaNewsletterAdminInviteInput {
+    readonly newsletterJid: string;
+    readonly userJid: string;
+}
+export interface WaNewsletterAdminInviteResult {
+    readonly inviteId?: string;
+    readonly expirationTime?: number;
+}
+export interface WaNewsletterSendOptions {
+    readonly stanzaId?: string;
+    readonly contextInfo?: WaSendContextInfo | null;
+    /**
+     * Extra attributes merged into the outgoing `<message>` stanza. Keys provided
+     * here override protocol-managed ones (`to`, `id`, `type`, `edit`, ...)  -
+     * use with care: bad overrides can break the send.
+     */
+    readonly additionalAttributes?: Readonly<Record<string, string>>;
+}
+export type WaNewsletterSendResult = WaMessagePublishResult;
+export interface WaNewsletterReactInput {
+    readonly newsletterJid: string;
+    readonly parentMessageServerId: number;
+    readonly reactionCode: string;
+    readonly stanzaId?: string;
+    readonly revoke?: boolean;
+}
+export interface WaNewsletterRevokeInput {
+    readonly newsletterJid: string;
+    readonly originalMessageId: string;
+}
+export interface WaNewsletterVotePollInput {
+    readonly newsletterJid: string;
+    readonly parentMessageServerId: number;
+    readonly votes: readonly Uint8Array[];
+    readonly stanzaId?: string;
+    readonly contentType?: string;
+}
+export interface WaNewsletterViewReceiptInput {
+    readonly newsletterJid: string;
+    readonly itemServerIds: readonly number[];
+    readonly stanzaId?: string;
+}
+export interface WaNewsletterAdminInfo {
+    readonly adminCount?: number;
+    readonly adminProfile: WaNewsletterAdminProfile | null;
+}
+export interface WaNewsletterAdminProfile {
+    readonly id?: string;
+    readonly name?: string;
+    readonly pictureId?: string;
+    readonly pictureDirectPath?: string;
+}
+export interface WaNewsletterFollower {
+    readonly id: string;
+    readonly displayName?: string;
+    readonly role?: WaNewsletterRole;
+    readonly phoneJid?: string;
+    readonly username?: string;
+    readonly followTime?: number;
+    readonly adminProfile: WaNewsletterAdminProfile | null;
+}
+export interface WaPageInfo {
+    readonly hasNextPage?: boolean;
+    readonly hasPreviousPage?: boolean;
+    readonly startCursor?: string;
+    readonly endCursor?: string;
+}
+export interface WaNewsletterFollowersPage {
+    readonly followers: readonly WaNewsletterFollower[];
+}
+export interface WaNewsletterDirectoryResults {
+    readonly results: readonly WaNewsletterMetadata[];
+    readonly pageInfo?: WaPageInfo;
+}
+export interface WaNewsletterDirectoryCategoryPreview {
+    readonly category: string;
+    readonly categoryTitle?: string;
+    readonly newsletters: readonly WaNewsletterMetadata[];
+}
+export interface WaNewsletterDehydratedMetadata {
+    readonly jid: string;
+    readonly subscribersCount?: number;
+    readonly verification?: string;
+    readonly reactionCodesSetting?: string;
+    readonly wamoSubPlanId?: string;
+    readonly wamoSubStatus?: string;
+}
+export interface WaNewsletterReactionSenders {
+    readonly reactionCode: string;
+    readonly senders: readonly {
+        readonly id: string;
+        readonly profileUrl?: string;
+    }[];
+}
+export interface WaNewsletterPollVoter {
+    readonly id: string;
+    readonly time?: number;
+}

package/dist/types/client/persistence/WriteBehindPersistence.d.ts

@@ -18,9 +18,20 @@ export interface WriteBehindDrainResult {
 }
 export declare class WriteBehindPersistence {
     private readonly logger;
-    private readonly queues;
+    private readonly stores;
+    private readonly options;
+    private queues;
     private readonly flushTimeoutMs;
+    private destroyed;
     constructor(stores: WriteBehindStores, logger: Logger, options?: WaWriteBehindOptions);
+    private buildQueues;
+    /**
+     * Re-arm the queues after a previous {@link destroy} call. Idempotent —
+     * a no-op when the persistence is already live. Used by `WaClient.connect`
+     * to recover from a logout/clear-stored-state cycle without leaking the
+     * old destroyed queues into the next session.
+     */
+    restart(): void;
     persistMessage(record: WaStoredMessageRecord): void;
     persistMessageAsync(record: WaStoredMessageRecord): Promise<void>;
     persistThread(record: WaStoredThreadRecord): void;

package/dist/types/client/persistence/history-sync.d.ts

@@ -0,0 +1,29 @@
+import type { WriteBehindPersistence } from '../persistence/WriteBehindPersistence';
+import type { WaClientEventMap } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMediaTransferClient } from '../../media/transfer/WaMediaTransferClient';
+import { type Proto } from '../../proto';
+interface WaHistorySyncDeps {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly writeBehind: WriteBehindPersistence;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly onPrivacyTokens?: (conversations: readonly {
+        readonly jid: string;
+        readonly tcToken?: Uint8Array | null;
+        readonly tcTokenTimestamp?: number | null;
+        readonly tcTokenSenderTimestamp?: number | null;
+    }[]) => Promise<void>;
+    readonly onNctSalt?: (salt: Uint8Array) => Promise<void>;
+    /**
+     * Invoked once per recognized chunk after it has been fully processed (or
+     * after the early-return for `INITIAL_STATUS_V3` and other recognized-but-
+     * unhandled types). The WaClient wires this to the `hist_sync` receipt
+     * stanza required by wa-web so the primary device does not keep resending
+     * the same chunk.
+     */
+    readonly onProcessed?: (syncType: Proto.Message.HistorySyncType) => Promise<void>;
+}
+export declare function runHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
+export declare function processHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
+export {};

package/dist/types/client/{mailbox.d.ts → persistence/mailbox.d.ts}

@@ -1,7 +1,7 @@
-import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
-import type { WaIncomingMessageEvent } from './types';
-import type { Logger } from '../infra/log/types';
-import type { WaMessageSecretStore } from '../store/contracts/message-secret.store';
+import type { WriteBehindPersistence } from '../persistence/WriteBehindPersistence';
+import type { WaIncomingMessageEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaMessageSecretStore } from '../../store/contracts/message-secret.store';
 interface WaPersistIncomingMailboxOptions {
     readonly logger: Logger;
     readonly writeBehind: WriteBehindPersistence;

package/dist/types/client/tokens/cs-token.d.ts

@@ -1,10 +1,8 @@
 export declare class CsTokenGenerator {
-    private cachedKey;
     private cachedSalt;
     private readonly cache;
     constructor();
-    generate(nctSalt: Uint8Array, accountLid: string): Promise<Uint8Array>;
+    generate(nctSalt: Uint8Array, accountLid: string): Uint8Array;
     invalidate(): void;
     private isSameSalt;
-    private resolveKey;
 }