@oxidezap/baileyrs 0.1.2 → 0.1.3

package/lib/Defaults/index.d.ts

@@ -62,6 +62,12 @@ export declare const MEDIA_HKDF_KEY_MAPPING: {
 };
 export type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING;
 export declare const MEDIA_KEYS: MediaType[];
+/**
+ * The type's own members, for checking one that arrives untyped. Readonly
+ * because it is public and the upload guard reads it: editing it would change
+ * what every caller is allowed to send.
+ */
+export declare const MEDIA_TYPES: readonly MediaType[];
 /** 120s timeout for history sync stall detection, matching upstream Baileys. */
 export declare const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
 export declare const MIN_PREKEY_COUNT = 5;

package/lib/Defaults/index.js

@@ -110,6 +110,12 @@ export const MEDIA_HKDF_KEY_MAPPING = {
     'biz-cover-photo': 'Image'
 };
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+/**
+ * The type's own members, for checking one that arrives untyped. Readonly
+ * because it is public and the upload guard reads it: editing it would change
+ * what every caller is allowed to send.
+ */
+export const MEDIA_TYPES = Object.keys(MEDIA_HKDF_KEY_MAPPING);
 /** 120s timeout for history sync stall detection, matching upstream Baileys. */
 export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
 export const MIN_PREKEY_COUNT = 5;

package/lib/Socket/blocking.d.ts

@@ -1,6 +1,8 @@
 import type { SocketContext } from './types.js';
+export declare const BLOCK_ACTIONS: readonly ['block', 'unblock'];
+export type BlockAction = (typeof BLOCK_ACTIONS)[number];
 export declare const makeBlockingMethods: (ctx: SocketContext) => {
-    updateBlockStatus: (jid: string, action: 'block' | 'unblock') => Promise<void>;
+    updateBlockStatus: (jid: string, action: BlockAction) => Promise<void>;
     fetchBlocklist: () => Promise<Array<string | undefined>>;
 };
 //# sourceMappingURL=blocking.d.ts.map

package/lib/Socket/blocking.js

@@ -1,6 +1,9 @@
 import { bridgeBlocklistToBaileys } from '../Compatibility/socket-results.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
+export const BLOCK_ACTIONS = ['block', 'unblock'];
 export const makeBlockingMethods = (ctx) => ({
     updateBlockStatus: async (jid, action) => {
+        assertArgumentDomain('updateBlockStatus', 'action', action, BLOCK_ACTIONS);
         await (await ctx.getClient()).updateBlockStatus(jid, action);
     },
     fetchBlocklist: async () => {

package/lib/Socket/communities.d.ts

@@ -1,4 +1,5 @@
-import type { GroupMetadata, ParticipantAction } from '../Types/index.js';
+import { type GroupMetadata, type ParticipantAction } from '../Types/index.js';
+import { type GroupRequestAction, type GroupSetting, type JoinApprovalMode, type MemberAddMode } from './groups.js';
 import type { SocketContext } from './types.js';
 type LinkedGroup = {
     id: string | undefined;
@@ -13,7 +14,7 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -23,9 +24,9 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
     groupAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("@oxidezap/whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: GroupSetting) => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: MemberAddMode) => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: JoinApprovalMode) => Promise<void>;
     groupFetchAllParticipating: () => Promise<Record<string, GroupMetadata>>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
 }) => {
@@ -42,7 +43,11 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
         linkedGroups: LinkedGroup[];
     }>;
     communityRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    /**
+     * The community methods that are the group operation check under their own
+     * name before delegating: a refusal has to name the method that was called.
+     */
+    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     communityParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     communityUpdateDescription: (jid: string, description?: string) => Promise<void>;
     communityInviteCode: (jid: string) => Promise<string | undefined>;
@@ -52,9 +57,9 @@ export declare const makeCommunityMethods: (ctx: SocketContext, groups?: {
     communityAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("@oxidezap/whatsapp-rust-bridge/proto-types").proto.Message.IGroupInviteMessage) => Promise<any>;
     communityGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     communityToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    communitySettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    communityMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    communityJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    communitySettingUpdate: (jid: string, setting: GroupSetting) => Promise<void>;
+    communityMemberAddMode: (jid: string, mode: MemberAddMode) => Promise<void>;
+    communityJoinApprovalMode: (jid: string, mode: JoinApprovalMode) => Promise<void>;
     communityFetchAllParticipating: () => Promise<Record<string, GroupMetadata>>;
 };
 export {};

package/lib/Socket/communities.js

@@ -1,6 +1,8 @@
 import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
 import { bridgeParticipantChangesToBaileys } from '../Compatibility/socket-results.js';
-import { makeGroupMethods } from './groups.js';
+import { PARTICIPANT_ACTIONS } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
+import { GROUP_REQUEST_ACTIONS, GROUP_SETTINGS, JOIN_APPROVAL_MODES, makeGroupMethods, MEMBER_ADD_MODES } from './groups.js';
 export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
     const communityMetadata = async (jid) => groups.groupMetadata(jid);
     const communityFetchAllParticipating = async () => {
@@ -49,8 +51,16 @@ export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
             return { communityJid, isCommunity, linkedGroups };
         },
         communityRequestParticipantsList: groups.groupRequestParticipantsList,
-        communityRequestParticipantsUpdate: groups.groupRequestParticipantsUpdate,
+        /**
+         * The community methods that are the group operation check under their own
+         * name before delegating: a refusal has to name the method that was called.
+         */
+        communityRequestParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('communityRequestParticipantsUpdate', 'action', action, GROUP_REQUEST_ACTIONS);
+            return groups.groupRequestParticipantsUpdate(jid, participants, action);
+        },
         communityParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('communityParticipantsUpdate', 'action', action, PARTICIPANT_ACTIONS);
             return bridgeParticipantChangesToBaileys(await (await ctx.getClient()).communityParticipantsUpdate(jid, participants, action));
         },
         communityUpdateDescription: groups.groupUpdateDescription,
@@ -63,9 +73,18 @@ export const makeCommunityMethods = (ctx, groups = makeGroupMethods(ctx)) => {
         communityAcceptInviteV4: groups.groupAcceptInviteV4,
         communityGetInviteInfo: groups.groupGetInviteInfo,
         communityToggleEphemeral: groups.groupToggleEphemeral,
-        communitySettingUpdate: groups.groupSettingUpdate,
-        communityMemberAddMode: groups.groupMemberAddMode,
-        communityJoinApprovalMode: groups.groupJoinApprovalMode,
+        communitySettingUpdate: async (jid, setting) => {
+            assertArgumentDomain('communitySettingUpdate', 'setting', setting, GROUP_SETTINGS);
+            return groups.groupSettingUpdate(jid, setting);
+        },
+        communityMemberAddMode: async (jid, mode) => {
+            assertArgumentDomain('communityMemberAddMode', 'mode', mode, MEMBER_ADD_MODES);
+            return groups.groupMemberAddMode(jid, mode);
+        },
+        communityJoinApprovalMode: async (jid, mode) => {
+            assertArgumentDomain('communityJoinApprovalMode', 'mode', mode, JOIN_APPROVAL_MODES);
+            return groups.groupJoinApprovalMode(jid, mode);
+        },
         communityFetchAllParticipating
     };
 };

package/lib/Socket/contacts.d.ts

@@ -1,4 +1,6 @@
 import type { SocketContext } from './types.js';
+export declare const PROFILE_PICTURE_TYPES: readonly ['preview', 'image'];
+export type ProfilePictureType = (typeof PROFILE_PICTURE_TYPES)[number];
 export type OnWhatsAppResult = {
     exists: boolean;
     jid: string;
@@ -11,7 +13,7 @@ export type OnWhatsAppResult = {
 };
 export declare const makeContactMethods: (ctx: SocketContext) => {
     onWhatsApp: (...phoneNumber: string[]) => Promise<OnWhatsAppResult[] | undefined>;
-    profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
+    profilePictureUrl: (jid: string, type?: ProfilePictureType, timeoutMs?: number) => Promise<string | undefined>;
     fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
 };
 //# sourceMappingURL=contacts.d.ts.map

package/lib/Socket/contacts.js

@@ -1,3 +1,5 @@
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
+export const PROFILE_PICTURE_TYPES = ['preview', 'image'];
 export const makeContactMethods = (ctx) => ({
     onWhatsApp: async (...phoneNumber) => {
         const client = await ctx.getClient();
@@ -16,6 +18,7 @@ export const makeContactMethods = (ctx) => ({
         });
     },
     profilePictureUrl: async (jid, type = 'preview', timeoutMs) => {
+        assertArgumentDomain('profilePictureUrl', 'type', type, PROFILE_PICTURE_TYPES);
         const result = await (await ctx.getClient()).profilePictureUrl(jid, type, timeoutMs);
         return result?.url;
     },

package/lib/Socket/groups.d.ts

@@ -1,14 +1,40 @@
 import { type GroupMetadata, type ParticipantAction, type WAMessageKey } from '../Types/index.js';
 import { proto } from '../WAProto/runtime.js';
 import type { SocketContext } from './types.js';
-type GroupSetting = 'announcement' | 'not_announcement' | 'locked' | 'unlocked';
+declare const GROUP_SETTING_ALIASES: {
+    readonly announcement: {
+        readonly setting: 'announce';
+        readonly value: true;
+    };
+    readonly not_announcement: {
+        readonly setting: 'announce';
+        readonly value: false;
+    };
+    readonly locked: {
+        readonly setting: 'locked';
+        readonly value: true;
+    };
+    readonly unlocked: {
+        readonly setting: 'locked';
+        readonly value: false;
+    };
+};
+/** The table is the definition: both the type and the accepted set come off it. */
+export type GroupSetting = keyof typeof GROUP_SETTING_ALIASES;
+export declare const GROUP_SETTINGS: readonly GroupSetting[];
+export declare const GROUP_REQUEST_ACTIONS: readonly ['approve', 'reject'];
+export type GroupRequestAction = (typeof GROUP_REQUEST_ACTIONS)[number];
+export declare const MEMBER_ADD_MODES: readonly ['admin_add', 'all_member_add'];
+export type MemberAddMode = (typeof MEMBER_ADD_MODES)[number];
+export declare const JOIN_APPROVAL_MODES: readonly ['on', 'off'];
+export type JoinApprovalMode = (typeof JOIN_APPROVAL_MODES)[number];
 export declare const makeGroupMethods: (ctx: SocketContext) => {
     groupMetadata: (jid: string) => Promise<GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     groupParticipantsUpdate: (jid: string, participants: string[], action: ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -19,8 +45,8 @@ export declare const makeGroupMethods: (ctx: SocketContext) => {
     groupGetInviteInfo: (code: string) => Promise<GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
     groupSettingUpdate: (jid: string, setting: GroupSetting) => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: MemberAddMode) => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: JoinApprovalMode) => Promise<void>;
     groupFetchAllParticipating: () => Promise<Record<string, GroupMetadata>>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
 };

package/lib/Socket/groups.js

@@ -1,6 +1,7 @@
 import { bridgeInviteLinkToCode, bridgeMembershipRequestsToBaileys, bridgeMembershipRequestUpdatesToBaileys, bridgeParticipantChangesToBaileys } from '../Compatibility/socket-results.js';
 import { emitMessageUpsert } from '../Compatibility/message-upsert.js';
-import { WAMessageStubType } from '../Types/index.js';
+import { PARTICIPANT_ACTIONS, WAMessageStubType } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/generics.js';
 import { proto } from '../WAProto/runtime.js';
 import { bridgeGroupMetadataToBaileys } from '../Compatibility/group-metadata.js';
@@ -10,6 +11,10 @@ const GROUP_SETTING_ALIASES = {
     locked: { setting: 'locked', value: true },
     unlocked: { setting: 'locked', value: false }
 };
+export const GROUP_SETTINGS = Object.keys(GROUP_SETTING_ALIASES);
+export const GROUP_REQUEST_ACTIONS = ['approve', 'reject'];
+export const MEMBER_ADD_MODES = ['admin_add', 'all_member_add'];
+export const JOIN_APPROVAL_MODES = ['on', 'off'];
 const inviteExpirationNumber = (value) => typeof value === 'number' ? value : (value?.toNumber() ?? 0);
 export const makeGroupMethods = (ctx) => {
     const groupMetadata = async (jid) => {
@@ -17,7 +22,8 @@ export const makeGroupMethods = (ctx) => {
         return bridgeGroupMetadataToBaileys(metadata);
     };
     const groupSettingUpdate = async (jid, setting) => {
-        const mapped = GROUP_SETTING_ALIASES[setting];
+        const checked = assertArgumentDomain('groupSettingUpdate', 'setting', setting, GROUP_SETTINGS);
+        const mapped = GROUP_SETTING_ALIASES[checked];
         await (await ctx.getClient()).groupSettingUpdate(jid, mapped.setting, mapped.value);
     };
     const groupAcceptInviteV4 = ctx.ev.createBufferedFunction(async (key, inviteMessage
@@ -71,9 +77,11 @@ export const makeGroupMethods = (ctx) => {
             return bridgeMembershipRequestsToBaileys(await (await ctx.getClient()).groupRequestParticipantsList(jid));
         },
         groupRequestParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('groupRequestParticipantsUpdate', 'action', action, GROUP_REQUEST_ACTIONS);
             return bridgeMembershipRequestUpdatesToBaileys(await (await ctx.getClient()).groupRequestParticipantsUpdate(jid, participants, action));
         },
         groupParticipantsUpdate: async (jid, participants, action) => {
+            assertArgumentDomain('groupParticipantsUpdate', 'action', action, PARTICIPANT_ACTIONS);
             return bridgeParticipantChangesToBaileys(await (await ctx.getClient()).groupParticipantsUpdate(jid, participants, action));
         },
         groupUpdateDescription: async (jid, description) => {
@@ -100,9 +108,13 @@ export const makeGroupMethods = (ctx) => {
         },
         groupSettingUpdate,
         groupMemberAddMode: async (jid, mode) => {
+            assertArgumentDomain('groupMemberAddMode', 'mode', mode, MEMBER_ADD_MODES);
             await (await ctx.getClient()).groupMemberAddMode(jid, mode);
         },
         groupJoinApprovalMode: async (jid, mode) => {
+            // Anything but 'on' used to mean off, so a typo turned approvals off
+            // and reported success.
+            assertArgumentDomain('groupJoinApprovalMode', 'mode', mode, JOIN_APPROVAL_MODES);
             await (await ctx.getClient()).groupSettingUpdate(jid, 'membership_approval', mode === 'on');
         },
         groupFetchAllParticipating: async () => {

package/lib/Socket/index.d.ts

@@ -2,15 +2,16 @@ import { Buffer } from 'node:buffer';
 import { type UploadMediaResult } from '@oxidezap/whatsapp-rust-bridge';
 import { WebSocketClient } from '../Compatibility/websocket-client.js';
 import { type MediaType } from '../Defaults/index.js';
-import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WABusinessProfile, WAMessage, WAMessageKey } from '../Types/index.js';
+import type { BinaryNode, AuthenticationCreds, ConnectionState, Contact, ReachoutTimelockState, SignalKeyStoreWithTransaction, UserFacingSocketConfig, WABusinessProfile, WAMessage, WAMessageKey, WAPresence } from '../Types/index.js';
 import type Long from 'long';
+import { type MediaDownloadType } from '../Utils/messages.js';
 import type { MediaDownloadOptions } from '../Utils/messages-media.js';
 import type { proto } from '../WAProto/runtime.js';
 /** Build the ws EventEmitter with auto-enable raw node forwarding */
 declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendMessageAck: (node: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
-    updateBlockStatus: (jid: string, action: 'block' | 'unblock') => Promise<void>;
+    updateBlockStatus: (jid: string, action: import("./blocking.js").BlockAction) => Promise<void>;
     fetchBlocklist: () => Promise<Array<string | undefined>>;
     getCatalog: ({ jid, limit, cursor }: import("../index.js").GetCatalogOptions) => Promise<import("../index.js").CatalogPage>;
     getCollections: (jid?: string, limit?: number) => Promise<import("../index.js").CollectionsPage>;
@@ -40,14 +41,14 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     addOrEditQuickReply: (quickReply: import("../Types/Bussines.js").QuickReplyAction) => Promise<void>;
     removeQuickReply: (timestamp: string) => Promise<void>;
     onWhatsApp: (...phoneNumber: string[]) => Promise<import("./contacts.js").OnWhatsAppResult[] | undefined>;
-    profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
+    profilePictureUrl: (jid: string, type?: import("./contacts.js").ProfilePictureType, timeoutMs?: number) => Promise<string | undefined>;
     fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("@oxidezap/whatsapp-rust-bridge").UserInfoResult>>;
     groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
     groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
     groupRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: import("./groups.js").GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     groupParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
     groupInviteCode: (jid: string) => Promise<string | undefined>;
@@ -57,9 +58,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     groupAcceptInviteV4: (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<any>;
     groupGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
     groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    groupMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    groupJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: import("./groups.js").GroupSetting) => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: import("./groups.js").MemberAddMode) => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: import("./groups.js").JoinApprovalMode) => Promise<void>;
     groupFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
     communityMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
@@ -81,7 +82,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         }[];
     }>;
     communityRequestParticipantsList: (jid: string) => Promise<Array<Record<string, string>>>;
-    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: 'approve' | 'reject') => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
+    communityRequestParticipantsUpdate: (jid: string, participants: string[], action: import("./groups.js").GroupRequestAction) => Promise<import("../Compatibility/socket-results.js").MembershipRequestUpdateResult[]>;
     communityParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<import("../Compatibility/socket-results.js").ParticipantUpdateResult[]>;
     communityUpdateDescription: (jid: string, description?: string) => Promise<void>;
     communityInviteCode: (jid: string) => Promise<string | undefined>;
@@ -91,9 +92,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     communityAcceptInviteV4: (key: string | WAMessageKey, inviteMessage: proto.Message.IGroupInviteMessage) => Promise<any>;
     communityGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
     communityToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
-    communitySettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
-    communityMemberAddMode: (jid: string, mode: 'admin_add' | 'all_member_add') => Promise<void>;
-    communityJoinApprovalMode: (jid: string, mode: 'on' | 'off') => Promise<void>;
+    communitySettingUpdate: (jid: string, setting: import("./groups.js").GroupSetting) => Promise<void>;
+    communityMemberAddMode: (jid: string, mode: import("./groups.js").MemberAddMode) => Promise<void>;
+    communityJoinApprovalMode: (jid: string, mode: import("./groups.js").JoinApprovalMode) => Promise<void>;
     communityFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
     waitForSocketOpen: () => Promise<void>;
     upsertMessage: (msg: WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
@@ -111,7 +112,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     sendReceipts: (keys: WAMessageKey[], type: import("../index.js").MessageReceiptType) => Promise<void>;
     requestPlaceholderResend: (messageKey: WAMessageKey, msgData?: Partial<WAMessage>) => Promise<string | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../index.js").NewsletterMetadata>;
-    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<import("../index.js").NewsletterMetadata | null>;
+    newsletterMetadata: (type: import("./newsletter.js").NewsletterKeyType, key: string) => Promise<import("../index.js").NewsletterMetadata | null>;
     newsletterUpdate: (jid: string, updates: import("../index.js").NewsletterUpdate) => Promise<import("../index.js").NewsletterMetadata>;
     newsletterUpdateName: (jid: string, name: string) => Promise<import("../index.js").NewsletterMetadata>;
     newsletterUpdateDescription: (jid: string, description: string) => Promise<import("../index.js").NewsletterMetadata>;
@@ -139,9 +140,9 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
     rotateSignedPreKey: () => Promise<void>;
-    sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
+    sendPresence: (status: import("../index.js").WAPresenceStatus) => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
-    sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    sendChatState: (jid: string, state: import("../index.js").WAChatState) => Promise<void>;
     fetchPrivacySettings: (force?: boolean) => Promise<any>;
     updatePrivacySetting: (category: string, value: string) => Promise<void>;
     updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
@@ -163,7 +164,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     fetchNewChatMessageCap: () => Promise<import("../index.js").NewChatMessageCapInfo & {
         remaining_quota?: number;
     }>;
-    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    cleanDirtyBits: (type: import("./server-queries.js").DirtyBitType, fromTimestamp?: number | string) => Promise<void>;
     sendPeerDataOperationMessage: (_pdoMessage: unknown) => Promise<never>;
     createCallLink: (_type: 'audio' | 'video', _event?: unknown, _timeoutMs?: number) => Promise<never>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
@@ -272,7 +273,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
      * caller hears about the protocol mistake instead of the bridge silently
      * sending nothing.
      */
-    sendPresenceUpdate: (type: 'available' | 'unavailable' | 'composing' | 'recording' | 'paused', toJid?: string) => Promise<void>;
+    sendPresenceUpdate: (type: WAPresence, toJid?: string) => Promise<void>;
     /**
      * Plaintext media upload helper, source-compatible with the upstream
      * Baileys `sock.waUploadToServer(buf, { mediaType })` shape so existing
@@ -303,7 +304,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     getBusinessProfile: (jid: string) => Promise<WABusinessProfile | void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
     sendStatusMessage: (message: Record<string, unknown>, recipients: string[]) => Promise<string>;
-    downloadMedia: <T extends 'buffer' | 'stream'>(message: WAMessage, type: T, options?: MediaDownloadOptions) => Promise<T extends "buffer" ? Buffer<ArrayBufferLike> : import("node:stream").Readable>;
+    downloadMedia: <T extends MediaDownloadType>(message: WAMessage, type: T, options?: MediaDownloadOptions) => Promise<T extends "buffer" ? Buffer<ArrayBufferLike> : import("node:stream").Readable>;
 };
 export default makeWASocket;
 //# sourceMappingURL=index.d.ts.map

package/lib/Socket/index.js

@@ -12,11 +12,12 @@ import { makeStanzaResponseMethods } from '../Compatibility/stanza-responses.js'
 import { makeParticipatingRefreshHandler } from '../Compatibility/participating-refresh.js';
 import { makeTaggedMessageWaiter } from '../Compatibility/tagged-message-waiter.js';
 import { isRawNodeForwardingEnabled, WebSocketClient } from '../Compatibility/websocket-client.js';
-import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
+import { DEFAULT_CONNECTION_CONFIG, MEDIA_TYPES } from '../Defaults/index.js';
+import { DisconnectReason, WA_PRESENCES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { makeEventBuffer } from '../Utils/event-buffer.js';
-import { _registerActiveBridgeClient, _unregisterActiveBridgeClient, downloadMediaMessage } from '../Utils/messages.js';
+import { _registerActiveBridgeClient, _unregisterActiveBridgeClient, downloadMediaMessage, MEDIA_DOWNLOAD_TYPES } from '../Utils/messages.js';
 import { makeNativeCryptoProvider } from '../Utils/native-crypto-provider.js';
 import { wrapLegacyStore } from '../Utils/wrap-legacy-store.js';
 import { assertNodeErrorFree } from '../WABinary/generic-utils.js';
@@ -828,6 +829,9 @@ const makeWASocket = (config) => {
          * sending nothing.
          */
         sendPresenceUpdate: async (type, toJid) => {
+            // Ahead of the client: an off-union value used to fall through to the
+            // chat-state branch and be reported as a missing jid.
+            assertArgumentDomain('sendPresenceUpdate', 'type', type, WA_PRESENCES);
             const c = await ctx.getClient();
             if (type === 'available' || type === 'unavailable') {
                 return c.sendPresence(type);
@@ -844,6 +848,9 @@ const makeWASocket = (config) => {
          * keep working. Delegates to the bridge's encrypt + CDN-failover upload.
          */
         waUploadToServer: async (data, opts) => {
+            // The upstream set, which is wider than what the bridge uploads:
+            // `toBridgeMediaType` below still refuses the ones it cannot map.
+            assertArgumentDomain('waUploadToServer', 'mediaType', opts?.mediaType, MEDIA_TYPES);
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
             return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
         },
@@ -897,6 +904,10 @@ const makeWASocket = (config) => {
         ...makeBusinessMethods(ctx),
         ...makeServerQueryMethods(ctx),
         downloadMedia: async (message, type, options = {}) => {
+            // Checked here as well as in the helper: the client is awaited while
+            // the context below is built, and a check past that await reports a
+            // stack without the caller in it.
+            assertArgumentDomain('downloadMedia', 'type', type, MEDIA_DOWNLOAD_TYPES);
             return downloadMediaMessage(message, type, options, {
                 logger,
                 reuploadRequest: (m) => sock.updateMediaMessage(m),

package/lib/Socket/messages.js

@@ -1,7 +1,8 @@
 import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
 import { planMessageRelay } from '../Compatibility/message-relay.js';
 import { receiptMessageKeys } from '../Compatibility/message-keys.js';
-import { WAProto } from '../Types/index.js';
+import { MESSAGE_RECEIPT_TYPES, WAProto } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { generateWAMessage, getContentType, normalizeMessageContent } from '../Utils/messages.js';
 import { jidNormalizedUser } from '../WABinary/index.js';
@@ -161,6 +162,9 @@ export const makeMessageMethods = (ctx) => ({
      * Not supported: 'hist_sync', 'peer_msg' (logged as warning)
      */
     sendReceipt: async (jid, participant, messageIds, type) => {
+        // Ahead of the empty-list exit: the types this method handles elsewhere
+        // resolve without sending anything, so a typo looked like a no-op.
+        assertArgumentDomain('sendReceipt', 'type', type, MESSAGE_RECEIPT_TYPES);
         if (!messageIds.length)
             return;
         if (type === 'read' || type === 'read-self') {
@@ -193,6 +197,7 @@ export const makeMessageMethods = (ctx) => ({
      * Send receipts for multiple message keys, grouped by JID and participant.
      */
     sendReceipts: async (keys, type) => {
+        assertArgumentDomain('sendReceipts', 'type', type, MESSAGE_RECEIPT_TYPES);
         const client = await ctx.getClient();
         const receiptKeys = receiptMessageKeys(keys);
         if (type === 'read' || type === 'read-self') {

package/lib/Socket/newsletter.d.ts

@@ -2,6 +2,8 @@ import type { NewsletterMetadataResult } from '@oxidezap/whatsapp-rust-bridge';
 import type { NewsletterMetadata, NewsletterUpdate } from '../Types/Newsletter.js';
 import type { WAMediaUpload } from '../Types/index.js';
 import type { SocketContext } from './types.js';
+export declare const NEWSLETTER_KEY_TYPES: readonly ['invite', 'jid'];
+export type NewsletterKeyType = (typeof NEWSLETTER_KEY_TYPES)[number];
 export declare const makeNewsletterMethods: (ctx: SocketContext) => {
     newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
     /**
@@ -9,7 +11,7 @@ export declare const makeNewsletterMethods: (ctx: SocketContext) => {
      * rather than one that inspects the key. Resolves to null when the
      * newsletter does not exist, matching upstream.
      */
-    newsletterMetadata: (type: 'invite' | 'jid', key: string) => Promise<NewsletterMetadata | null>;
+    newsletterMetadata: (type: NewsletterKeyType, key: string) => Promise<NewsletterMetadata | null>;
     /**
      * `picture` is base64 of an already-generated image, and the empty string
      * means remove, as upstream builds it. The core splits those into two

package/lib/Socket/newsletter.js

@@ -1,7 +1,9 @@
 import { Buffer } from 'node:buffer';
 import { bridgeNewsletterMetadataToBaileys } from '../Compatibility/newsletter-results.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
 import { generateProfilePicture } from '../Utils/messages-media.js';
+export const NEWSLETTER_KEY_TYPES = ['invite', 'jid'];
 export const makeNewsletterMethods = (ctx) => ({
     newsletterCreate: async (name, description) => {
         return bridgeNewsletterMetadataToBaileys(await (await ctx.getClient()).newsletterCreate(name, description ?? null));
@@ -12,9 +14,7 @@ export const makeNewsletterMethods = (ctx) => ({
      * newsletter does not exist, matching upstream.
      */
     newsletterMetadata: async (type, key) => {
-        if (type !== 'invite' && type !== 'jid') {
-            throw new Boom(`newsletterMetadata: unknown key type '${type}'`, { statusCode: 400 });
-        }
+        assertArgumentDomain('newsletterMetadata', 'type', type, NEWSLETTER_KEY_TYPES);
         const client = await ctx.getClient();
         const result = type === 'invite' ? await client.newsletterMetadataByInvite(key) : await client.newsletterMetadata(key);
         return result ? bridgeNewsletterMetadataToBaileys(result) : null;

package/lib/Socket/presence.d.ts

@@ -1,7 +1,8 @@
+import { type WAChatState, type WAPresenceStatus } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makePresenceMethods: (ctx: SocketContext) => {
-    sendPresence: (status: 'available' | 'unavailable') => Promise<void>;
+    sendPresence: (status: WAPresenceStatus) => Promise<void>;
     presenceSubscribe: (toJid: string) => Promise<void>;
-    sendChatState: (jid: string, state: 'composing' | 'recording' | 'paused') => Promise<void>;
+    sendChatState: (jid: string, state: WAChatState) => Promise<void>;
 };
 //# sourceMappingURL=presence.d.ts.map

package/lib/Socket/presence.js

@@ -1,11 +1,15 @@
+import { WA_CHAT_STATES, WA_PRESENCE_STATUSES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const makePresenceMethods = (ctx) => ({
     sendPresence: async (status) => {
+        assertArgumentDomain('sendPresence', 'status', status, WA_PRESENCE_STATUSES);
         await (await ctx.getClient()).sendPresence(status);
     },
     presenceSubscribe: async (toJid) => {
         await (await ctx.getClient()).presenceSubscribe(toJid);
     },
     sendChatState: async (jid, state) => {
+        assertArgumentDomain('sendChatState', 'state', state, WA_CHAT_STATES);
         await (await ctx.getClient()).sendChatState(jid, state);
     }
 });

package/lib/Socket/privacy.d.ts

@@ -1,7 +1,13 @@
-import type { WAPrivacyCallValue, WAPrivacyGroupAddValue, WAPrivacyMessagesValue, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '../Types/index.js';
+import { type WAPrivacyCallValue, type WAPrivacyGroupAddValue, type WAPrivacyMessagesValue, type WAPrivacyOnlineValue, type WAPrivacyValue, type WAReadReceiptsValue } from '../Types/index.js';
 import type { SocketContext } from './types.js';
 export declare const makePrivacyMethods: (ctx: SocketContext) => {
     fetchPrivacySettings: (force?: boolean) => Promise<any>;
+    /**
+     * The untyped escape hatch, left open on purpose: the bridge takes both
+     * halves as plain strings and the core's wire enums carry a fallback, so
+     * this is the way to reach a category or value the wrappers below do not
+     * name yet. The wrappers are the checked path.
+     */
     updatePrivacySetting: (category: string, value: string) => Promise<void>;
     updateLastSeenPrivacy: (value: WAPrivacyValue) => Promise<void>;
     updateOnlinePrivacy: (value: WAPrivacyOnlineValue) => Promise<void>;

package/lib/Socket/privacy.js

@@ -1,3 +1,5 @@
+import { WA_PRIVACY_CALL_VALUES, WA_PRIVACY_GROUP_ADD_VALUES, WA_PRIVACY_MESSAGES_VALUES, WA_PRIVACY_ONLINE_VALUES, WA_PRIVACY_VALUES, WA_READ_RECEIPTS_VALUES } from '../Types/index.js';
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const makePrivacyMethods = (ctx) => {
     /** Per socket, so a send loop calling this does not flood the log. */
     let warnedAboutPrivacyTokens = false;
@@ -6,31 +8,45 @@ export const makePrivacyMethods = (ctx) => {
             void force;
             return (await ctx.getClient()).fetchPrivacySettings();
         },
+        /**
+         * The untyped escape hatch, left open on purpose: the bridge takes both
+         * halves as plain strings and the core's wire enums carry a fallback, so
+         * this is the way to reach a category or value the wrappers below do not
+         * name yet. The wrappers are the checked path.
+         */
         updatePrivacySetting: async (category, value) => {
             await (await ctx.getClient()).updatePrivacySetting(category, value);
         },
         updateLastSeenPrivacy: async (value) => {
+            assertArgumentDomain('updateLastSeenPrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('last', value);
         },
         updateOnlinePrivacy: async (value) => {
+            assertArgumentDomain('updateOnlinePrivacy', 'value', value, WA_PRIVACY_ONLINE_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('online', value);
         },
         updateProfilePicturePrivacy: async (value) => {
+            assertArgumentDomain('updateProfilePicturePrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('profile', value);
         },
         updateStatusPrivacy: async (value) => {
+            assertArgumentDomain('updateStatusPrivacy', 'value', value, WA_PRIVACY_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('status', value);
         },
         updateReadReceiptsPrivacy: async (value) => {
+            assertArgumentDomain('updateReadReceiptsPrivacy', 'value', value, WA_READ_RECEIPTS_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('readreceipts', value);
         },
         updateGroupsAddPrivacy: async (value) => {
+            assertArgumentDomain('updateGroupsAddPrivacy', 'value', value, WA_PRIVACY_GROUP_ADD_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('groupadd', value);
         },
         updateCallPrivacy: async (value) => {
+            assertArgumentDomain('updateCallPrivacy', 'value', value, WA_PRIVACY_CALL_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('calladd', value);
         },
         updateMessagesPrivacy: async (value) => {
+            assertArgumentDomain('updateMessagesPrivacy', 'value', value, WA_PRIVACY_MESSAGES_VALUES);
             await (await ctx.getClient()).updatePrivacySetting('messages', value);
         },
         /**

package/lib/Socket/server-queries.d.ts

@@ -2,6 +2,8 @@ import type { BotListInfo } from '../Types/Chat.js';
 import type { NewChatMessageCapInfo } from '../Types/State.js';
 import type { MediaConnInfo } from '../Types/Message.js';
 import type { SocketContext } from './types.js';
+export declare const DIRTY_BIT_TYPES: readonly ['account_sync', 'groups'];
+export type DirtyBitType = (typeof DIRTY_BIT_TYPES)[number];
 export declare const makeServerQueryMethods: (ctx: SocketContext) => {
     /**
      * `maxContentLengthBytes` is absent by design: the core's hosts carry
@@ -19,7 +21,7 @@ export declare const makeServerQueryMethods: (ctx: SocketContext) => {
     fetchNewChatMessageCap: () => Promise<NewChatMessageCapInfo & {
         remaining_quota?: number;
     }>;
-    cleanDirtyBits: (type: 'account_sync' | 'groups', fromTimestamp?: number | string) => Promise<void>;
+    cleanDirtyBits: (type: DirtyBitType, fromTimestamp?: number | string) => Promise<void>;
     /**
      * Refused rather than wired up. The core already fires a peer data
      * request itself when a message fails to decrypt, with its own age

package/lib/Socket/server-queries.js

@@ -1,4 +1,6 @@
+import { assertArgumentDomain } from '../Utils/argument-domain.js';
 import { Boom } from '../Utils/boom.js';
+export const DIRTY_BIT_TYPES = ['account_sync', 'groups'];
 /**
  * Every section, flattened and deduplicated, rather than only the section the
  * server types `all`.
@@ -85,6 +87,7 @@ export const makeServerQueryMethods = (ctx) => {
             return toCapInfo(await (await ctx.getClient()).fetchNewChatMessageCappingInfo());
         },
         cleanDirtyBits: async (type, fromTimestamp) => {
+            assertArgumentDomain('cleanDirtyBits', 'type', type, DIRTY_BIT_TYPES);
             let timestamp = null;
             if (fromTimestamp !== undefined) {
                 // A blank string is not a timestamp, and `Number('')` is the epoch,

package/lib/Types/Chat.d.ts

@@ -6,15 +6,33 @@ import type { LabelActionBody } from './Label.js';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation.js';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation.js';
 import type { MinimalMessage, WAMessageKey } from './Message.js';
-/** privacy settings in WhatsApp Web */
-export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
-export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
-export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist';
-export type WAReadReceiptsValue = 'all' | 'none';
-export type WAPrivacyCallValue = 'all' | 'known';
-export type WAPrivacyMessagesValue = 'all' | 'contacts';
+/**
+ * privacy settings in WhatsApp Web
+ *
+ * Each of these is a set first and a type second: the wrappers that take one
+ * check the value against the same array the type is derived from, so a value
+ * cannot be accepted by the compiler and refused at runtime, or the reverse.
+ */
+export declare const WA_PRIVACY_VALUES: readonly ['all', 'contacts', 'contact_blacklist', 'none'];
+export type WAPrivacyValue = (typeof WA_PRIVACY_VALUES)[number];
+export declare const WA_PRIVACY_ONLINE_VALUES: readonly ['all', 'match_last_seen'];
+export type WAPrivacyOnlineValue = (typeof WA_PRIVACY_ONLINE_VALUES)[number];
+export declare const WA_PRIVACY_GROUP_ADD_VALUES: readonly ['all', 'contacts', 'contact_blacklist'];
+export type WAPrivacyGroupAddValue = (typeof WA_PRIVACY_GROUP_ADD_VALUES)[number];
+export declare const WA_READ_RECEIPTS_VALUES: readonly ['all', 'none'];
+export type WAReadReceiptsValue = (typeof WA_READ_RECEIPTS_VALUES)[number];
+export declare const WA_PRIVACY_CALL_VALUES: readonly ['all', 'known'];
+export type WAPrivacyCallValue = (typeof WA_PRIVACY_CALL_VALUES)[number];
+export declare const WA_PRIVACY_MESSAGES_VALUES: readonly ['all', 'contacts'];
+export type WAPrivacyMessagesValue = (typeof WA_PRIVACY_MESSAGES_VALUES)[number];
+/** the two the account itself broadcasts, as opposed to the per-chat states */
+export declare const WA_PRESENCE_STATUSES: readonly ['unavailable', 'available'];
+export type WAPresenceStatus = (typeof WA_PRESENCE_STATUSES)[number];
+export declare const WA_CHAT_STATES: readonly ['composing', 'recording', 'paused'];
+export type WAChatState = (typeof WA_CHAT_STATES)[number];
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
-export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export declare const WA_PRESENCES: readonly ["unavailable", "available", "composing", "recording", "paused"];
+export type WAPresence = (typeof WA_PRESENCES)[number];
 export declare const ALL_WA_PATCH_NAMES: readonly ['critical_block', 'critical_unblock_low', 'regular_high', 'regular_low', 'regular'];
 export type WAPatchName = (typeof ALL_WA_PATCH_NAMES)[number];
 export interface PresenceData {

package/lib/Types/Chat.js

@@ -1,3 +1,21 @@
+/**
+ * privacy settings in WhatsApp Web
+ *
+ * Each of these is a set first and a type second: the wrappers that take one
+ * check the value against the same array the type is derived from, so a value
+ * cannot be accepted by the compiler and refused at runtime, or the reverse.
+ */
+export const WA_PRIVACY_VALUES = ['all', 'contacts', 'contact_blacklist', 'none'];
+export const WA_PRIVACY_ONLINE_VALUES = ['all', 'match_last_seen'];
+export const WA_PRIVACY_GROUP_ADD_VALUES = ['all', 'contacts', 'contact_blacklist'];
+export const WA_READ_RECEIPTS_VALUES = ['all', 'none'];
+export const WA_PRIVACY_CALL_VALUES = ['all', 'known'];
+export const WA_PRIVACY_MESSAGES_VALUES = ['all', 'contacts'];
+/** the two the account itself broadcasts, as opposed to the per-chat states */
+export const WA_PRESENCE_STATUSES = ['unavailable', 'available'];
+export const WA_CHAT_STATES = ['composing', 'recording', 'paused'];
+/** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
+export const WA_PRESENCES = [...WA_PRESENCE_STATUSES, ...WA_CHAT_STATES];
 export const ALL_WA_PATCH_NAMES = [
     'critical_block',
     'critical_unblock_low',

package/lib/Types/GroupMetadata.d.ts

@@ -5,7 +5,9 @@ export type GroupParticipant = Contact & {
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
 };
-export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote' | 'modify';
+export declare const PARTICIPANT_ACTIONS: readonly ['add', 'remove', 'promote', 'demote', 'modify'];
+/** Derived from the values, so the runtime check and the type cannot drift. */
+export type ParticipantAction = (typeof PARTICIPANT_ACTIONS)[number];
 export type RequestJoinAction = 'created' | 'revoked' | 'rejected';
 export type RequestJoinMethod = 'invite_link' | 'linked_group_join' | 'non_admin_add' | undefined;
 export interface GroupMetadata {

package/lib/Types/GroupMetadata.js

@@ -1,2 +1,2 @@
-export {};
+export const PARTICIPANT_ACTIONS = ['add', 'remove', 'promote', 'demote', 'modify'];
 //# sourceMappingURL=GroupMetadata.js.map

package/lib/Types/Message.d.ts

@@ -51,7 +51,9 @@ export type MessageType = keyof proto.Message;
 export declare const WAMessageAddressingMode: typeof WAMessageAddressingModeType;
 export type WAMessageAddressingMode = WAMessageAddressingModeType;
 export type MessageWithContextInfo = 'imageMessage' | 'contactMessage' | 'locationMessage' | 'extendedTextMessage' | 'documentMessage' | 'audioMessage' | 'videoMessage' | 'call' | 'contactsArrayMessage' | 'liveLocationMessage' | 'templateMessage' | 'stickerMessage' | 'groupInviteMessage' | 'templateButtonReplyMessage' | 'productMessage' | 'listMessage' | 'orderMessage' | 'listResponseMessage' | 'buttonsMessage' | 'buttonsResponseMessage' | 'interactiveMessage' | 'interactiveResponseMessage' | 'pollCreationMessage' | 'requestPhoneNumberMessage' | 'messageHistoryBundle' | 'eventMessage' | 'newsletterAdminInviteMessage' | 'albumMessage' | 'stickerPackMessage' | 'pollResultSnapshotMessage' | 'messageHistoryNotice';
-export type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined;
+/** `undefined` is a member: it is how upstream spells a delivery receipt. */
+export declare const MESSAGE_RECEIPT_TYPES: readonly ['read', 'read-self', 'hist_sync', 'peer_msg', 'sender', 'inactive', 'played', undefined];
+export type MessageReceiptType = (typeof MESSAGE_RECEIPT_TYPES)[number];
 export type MediaConnInfo = {
     auth: string;
     ttl: number;

package/lib/Types/Message.js

@@ -7,4 +7,15 @@ export const WAMessageAddressingMode = Object.freeze({
     PN: 'pn',
     LID: 'lid'
 });
+/** `undefined` is a member: it is how upstream spells a delivery receipt. */
+export const MESSAGE_RECEIPT_TYPES = [
+    'read',
+    'read-self',
+    'hist_sync',
+    'peer_msg',
+    'sender',
+    'inactive',
+    'played',
+    undefined
+];
 //# sourceMappingURL=Message.js.map

package/lib/Utils/argument-domain.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Refuse a value outside a closed set, naming the method, the parameter, what
+ * arrived and everything that is accepted.
+ *
+ * Call it in the synchronous prefix of the public method, ahead of the first
+ * `await`. That is what puts the caller's own frame in the stack: a
+ * fire-and-forget call leaves no awaiting frame for V8 to stitch an async
+ * stack onto, and past the bridge boundary the rejection is built inside wasm
+ * and carries nothing but wasm frames.
+ *
+ * The domain is always the values that define the parameter's type, never a
+ * second list written beside it.
+ */
+export declare const assertArgumentDomain: <Value extends string | undefined>(method: string, parameter: string, value: unknown, domain: readonly Value[]) => Value;
+//# sourceMappingURL=argument-domain.d.ts.map

package/lib/Utils/argument-domain.js

@@ -0,0 +1,36 @@
+import { Boom } from './boom.js';
+/** Quoted when it is a string, bare otherwise, so `""` and `undefined` read apart. */
+const shown = (value) => {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    try {
+        return String(value);
+    }
+    catch {
+        // A null-prototype object, a revoked proxy, a trap that throws. `typeof`
+        // reads nothing off the value, so reporting it cannot fail on it.
+        return `[${typeof value}]`;
+    }
+};
+/**
+ * Refuse a value outside a closed set, naming the method, the parameter, what
+ * arrived and everything that is accepted.
+ *
+ * Call it in the synchronous prefix of the public method, ahead of the first
+ * `await`. That is what puts the caller's own frame in the stack: a
+ * fire-and-forget call leaves no awaiting frame for V8 to stitch an async
+ * stack onto, and past the bridge boundary the rejection is built inside wasm
+ * and carries nothing but wasm frames.
+ *
+ * The domain is always the values that define the parameter's type, never a
+ * second list written beside it.
+ */
+export const assertArgumentDomain = (method, parameter, value, domain) => {
+    if (domain.includes(value))
+        return value;
+    const error = new Boom(`${method}: ${JSON.stringify(parameter)} must be one of ${domain.map(shown).join(', ')}, received ${shown(value)}`, { statusCode: 400, data: { parameter, value, accepted: [...domain] } });
+    // Drop this frame: the method the consumer called is the useful top.
+    Error.captureStackTrace(error, assertArgumentDomain);
+    throw error;
+};
+//# sourceMappingURL=argument-domain.js.map

package/lib/Utils/messages.d.ts

@@ -55,6 +55,8 @@ export type DownloadMediaMessageContext = {
     /** Bridge client for media download. Falls back to the registered one. */
     waClient?: Pick<WasmWhatsAppClient, 'downloadMedia' | 'downloadMediaStream'>;
 };
+export declare const MEDIA_DOWNLOAD_TYPES: readonly ['buffer', 'stream'];
+export type MediaDownloadType = (typeof MEDIA_DOWNLOAD_TYPES)[number];
 /**
  * Downloads the given message. Throws an error if it's not a media message.
  *
@@ -68,7 +70,7 @@ export type DownloadMediaMessageContext = {
  * several sockets should pass `ctx` explicitly, because the registration points
  * at whichever client was created last.
  */
-export declare const downloadMediaMessage: <Type extends 'buffer' | 'stream'>(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Readable>;
+export declare const downloadMediaMessage: <Type extends MediaDownloadType>(message: WAMessage, type: Type, options: MediaDownloadOptions, ctx?: DownloadMediaMessageContext) => Promise<Type extends "buffer" ? Buffer<ArrayBufferLike> : Readable>;
 export declare const _registerActiveBridgeClient: (client: WasmWhatsAppClient, logger?: ILogger) => void;
 /**
  * Drop the module-level pointer when `sock.end()` frees the client it points

package/lib/Utils/messages.js

@@ -6,6 +6,7 @@ import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT
 import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { proto } from '../WAProto/runtime.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { assertArgumentDomain } from './argument-domain.js';
 import { Boom } from './boom.js';
 import { sha256 } from './crypto.js';
 import { getKeyAuthor, toNumber, unixTimestampSeconds } from './generics.js';
@@ -664,6 +665,7 @@ export const extractMessageContent = (content) => {
     }
     return content;
 };
+export const MEDIA_DOWNLOAD_TYPES = ['buffer', 'stream'];
 /**
  * Downloads the given message. Throws an error if it's not a media message.
  *
@@ -678,6 +680,9 @@ export const extractMessageContent = (content) => {
  * at whichever client was created last.
  */
 export const downloadMediaMessage = async (message, type, options, ctx) => {
+    // Anything but 'buffer' used to take the stream branch, so a typo returned
+    // a Readable to a caller holding it as a Buffer.
+    assertArgumentDomain('downloadMediaMessage', 'type', type, MEDIA_DOWNLOAD_TYPES);
     const waClient = ctx?.waClient ?? activeBridgeClient;
     if (!waClient) {
         throw new Boom('downloadMediaMessage: no bridge client available, and the download, its CDN failover and its decryption all happen in the engine. Pass `{ waClient: sock.waClient }`, use `sock.downloadMedia(message, type, options)`, or call after `makeWASocket()` has initialized.', { statusCode: 500 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxidezap/baileyrs",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A Rust-powered WhatsApp Web library for JavaScript, with a Baileys-compatible API",
   "keywords": [
     "whatsapp",
@@ -76,7 +76,7 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.4",
-    "@oxidezap/whatsapp-rust-bridge": "0.7.0",
+    "@oxidezap/whatsapp-rust-bridge": "0.7.1",
     "long": "^5.3.2",
     "pino": "^10.3.1",
     "protobufjs": "^7.6.5"