@codexverified/baileys 2.10.12 → 2.11.12

package/README.md

@@ -1,19 +1,44 @@
 # @codexverified/baileys
 
+[![npm version](https://img.shields.io/npm/v/@codexverified/baileys.svg)](https://www.npmjs.com/package/@codexverified/baileys)
+[![node](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](#at-a-glance)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](#license-and-maintenance)
+[![types](https://img.shields.io/badge/types-included-blue)](#at-a-glance)
+
 > A readable, carefully maintained Baileys distribution for building reliable WhatsApp integrations with codexverified/baileys.
 
 `@codexverified/baileys` is a Node.js and TypeScript library for creating WhatsApp automations over the Baileys protocol. It provides a socket-oriented API for authentication, messaging, media, interactive content, rich responses, newsletters, groups, communities, business features, account utilities, and carefully documented extensions.
 
 The package is maintained by **Codex** under the **CodexVerified** organization. It is intended for developers who want a practical Baileys foundation with familiar interfaces, public TypeScript declarations, readable source code, explicit behavior, and room for carefully tested improvements.
 
-## At a glance
+## Table of contents
+
+- [At a glance](#at-a-glance)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [CommonJS usage](#commonjs-usage)
+- [Core capabilities](#core-capabilities)
+- [Everyday message usage](#everyday-message-usage)
+- [Rich menu example](#rich-menu-example)
+- [Status, grids, tables, and flows](#status-grids-tables-and-flows)
+- [Authentication and deployment guidance](#authentication-and-deployment-guidance)
+- [Development workflow](#development-workflow)
+- [Recent compatibility updates](#recent-compatibility-updates)
+- [About Codex](#about-codex)
+- [Package layout](#package-layout)
+- [Security and responsible use](#security-and-responsible-use)
+- [License and maintenance](#license-and-maintenance)
+- [Compatibility additions](#compatibility-additions)
+- [Comparison references](#comparison-references)
+- [Additional functional compatibility helpers](#additional-functional-compatibility-helpers)
+- [AI generation primitive](#ai-generation-primitive)
 
-This release is version **2.10.12**. It uses ECMAScript modules, supports CommonJS usage where the installed Node.js version permits it, ships public TypeScript declarations, and targets Node.js 20 or newer.
+## At a glance
 
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.10.12` |
+| Version | `2.11.12` |
 | Runtime | Node.js 20 or newer |
 | Module format | ESM, with CommonJS compatibility where supported |
 | Type declarations | Included at `lib/index.d.ts` |
@@ -24,30 +49,18 @@ This release is version **2.10.12**. It uses ECMAScript modules, supports Common
 
 ## Installation
 
-Install the package from npm when it is published under your organization:
-
-```bash
-npm install @codexverified/baileys
-```
-
-To install a local package archive, place the `.tgz` file beside your application and run:
+| Method | Command | Notes |
+| --- | --- | --- |
+| From npm | `npm install @codexverified/baileys` | Standard install when published under your organization |
+| From local archive | `npm install ./codex-baileys-2.11.12.tgz` | Place the `.tgz` beside your application |
+| Source audit (no scripts) | `npm install --ignore-scripts` | Skips install hooks for local review |
 
-```bash
-npm install ./codex-baileys-2.10.12.tgz
-```
-
-Both installation methods use the same import name:
+Both npm and archive installs use the same import name:
 
 ```javascript
 import { makeWASocket } from '@codexverified/baileys'
 ```
 
-For local source auditing, install dependencies without executing package installation hooks:
-
-```bash
-npm install --ignore-scripts
-```
-
 ## Quick start
 
 The following example creates a socket, stores multi-file authentication credentials, reconnects after an unexpected disconnect, and replies to incoming messages. Keep the session directory private and never commit it to a public repository.
@@ -99,8 +112,6 @@ start().catch(console.error)
 
 ## CommonJS usage
 
-For supported Node.js versions, the package can also be loaded through CommonJS:
-
 ```javascript
 const {
   makeWASocket,
@@ -112,88 +123,52 @@ If your runtime or bundler does not support this interop path, use the ESM impor
 
 ## Core capabilities
 
-### Connections and authentication
-
-The socket layer manages WebSocket connection events, reconnect handling, browser identity configuration, pairing-code flows, and connection state transitions. Authentication helpers include multi-file credentials for standard deployments, single-file state for compact setups, SQLite-backed persistence when the optional driver is installed, and cache-manager integrations for applications that need custom persistence.
-
-### Messages and conversations
-
-The message API supports text, mentions, replies, reactions, edits, deletions, forwards, polls, contacts, locations, events, group invitations, quoted messages, disappearing messages, view-once envelopes, and other protocol message types. Message composition is centralized so applications can use the ordinary `sendMessage` flow while opting into advanced structures when required.
-
-### Media and albums
-
-Images, video, audio, documents, stickers, thumbnails, and albums are supported. Media can be prepared from URLs, local files, or buffers according to the upload configuration. Video messages can opt into GIF playback, and the image-processing layer can use an available `sharp`, `@napi-rs/image`, or `jimp` implementation. Album child-message association uses the WhatsApp-compatible wire value.
-
-### Interactive content
-
-The package includes interactive buttons, lists, native flows, hydrated templates, carousel layouts, button grids, and other structured message formats. Interactive identifiers should be stable and unique within the application. Receiving code should handle the possibility that different WhatsApp clients deliver a selected value through different response envelopes.
-
-### Rich content and previews
-
-Rich-response utilities cover code blocks, tables, inline entities, LaTeX-oriented content, link previews, and structured response arrays. Rich previews can fetch a title, description, and image for a URL when the optional dependency and network access are available. Applications should retain a plain-text fallback for clients that do not render rich content.
-
-### Rich menus
-
-The experimental `richMenu` helper builds a structured rich-response envelope with an optional header image, row or carousel cards, stable button identifiers, toast metadata, disclaimers, and a footer action. The package also exposes lower-level preparation utilities for applications that need more control. Rich menus are client-dependent and should be tested against the WhatsApp versions used by the application.
-
-### Groups and communities
-
-Group operations include group creation, participant management, settings, metadata, invites, labels, and community relationships. Community helpers support linked groups and subgroup operations where the connected account and current protocol permit them.
-
-### Newsletters and channel operations
-
-Newsletter utilities cover channel metadata, following and unfollowing, posts, reactions, media, and polls. Following is consumer-controlled: the library does not silently follow a trusted channel, inject a fallback channel identifier, or add an automatic channel pill to generated media. Applications should request newsletter actions explicitly and validate identifiers before sending requests.
-
-### Account, business, and privacy tools
-
-The package includes profile and business helpers, product and catalog operations, privacy controls, username utilities, account-layer and interoperation helpers, status publishing, favorites management, and selected account-management operations. Availability depends on the connected account, WhatsApp rollout, and the permissions associated with that account.
-
-### Storage and protocol utilities
-
-The distribution includes in-memory and ordered-dictionary stores, cache-manager support, authentication persistence, LID and phone-number resolution, event utilities, message normalization, media retry handling, protocol helpers, and TypeScript declarations in `lib/index.d.ts`.
+| Area | What it covers |
+| --- | --- |
+| Connections & authentication | WebSocket connection events, reconnect handling, browser identity configuration, pairing-code flows, connection state transitions |
+| Auth persistence | Multi-file credentials, single-file state, SQLite-backed persistence (optional driver), cache-manager integrations |
+| Messages & conversations | Text, mentions, replies, reactions, edits, deletions, forwards, polls, contacts, locations, events, group invitations, quoted messages, disappearing messages, view-once envelopes |
+| Media & albums | Images, video, audio, documents, stickers, thumbnails, albums; sourced from URLs, local files, or buffers; optional `sharp` / `@napi-rs/image` / `jimp` image processing; GIF-style video playback |
+| Interactive content | Buttons, lists, native flows, hydrated templates, carousel layouts, button grids |
+| Rich content & previews | Code blocks, tables, inline entities, LaTeX-oriented content, link previews, structured response arrays |
+| Rich menus (experimental) | Header image, row/carousel cards, stable button IDs, toast metadata, disclaimers, footer action |
+| Groups & communities | Group creation, participant management, settings, metadata, invites, labels, community/subgroup relationships |
+| Newsletters & channels | Channel metadata, follow/unfollow, posts, reactions, media, polls |
+| Account, business & privacy | Profile/business helpers, product & catalog operations, privacy controls, username utilities, status publishing, favorites management |
+| Storage & protocol utilities | In-memory and ordered-dictionary stores, cache-manager support, LID/phone-number resolution, event utilities, message normalization, media retry handling, TypeScript declarations |
 
 ## Everyday message usage
 
-Send a text message with the standard socket method:
+| Message type | Key options | Example |
+| --- | --- | --- |
+| Text | `text` | `sock.sendMessage(jid, { text: '...' })` |
+| Media with caption | `image` / `video` / `audio` / `document`, `caption` | `sock.sendMessage(jid, { image: { url } , caption: '...' })` |
+| GIF-style video | `video`, `gifPlayback: true` | `sock.sendMessage(jid, { video: { url }, gifPlayback: true })` |
+| View-once media | `viewOnce: true` (also `viewOnceV2`, `viewOnceV2Extension`, `spoiler`) | `sock.sendMessage(jid, { image: { url }, viewOnce: true })` |
+| Spoiler / view-once (new) | `mediaSpoilerMode: 'viewOnce' \| 'native'` | see below |
 
 ```javascript
 await sock.sendMessage(jid, {
   text: 'A message from Codex'
 })
-```
-
-Send media with a caption:
 
-```javascript
 await sock.sendMessage(jid, {
   image: { url: './media/photo.jpg' },
   caption: 'A photo message'
 })
-```
-
-Send a video with GIF-style playback enabled:
 
-```javascript
 await sock.sendMessage(jid, {
   video: { url: './media/animation.mp4' },
   gifPlayback: true,
   caption: 'Animated media'
 })
-```
 
-Use the existing explicit view-once options when you want the media to use a view-once envelope:
-
-```javascript
 await sock.sendMessage(jid, {
   image: { url: './media/private-image.jpg' },
   caption: 'Open once',
   viewOnce: true
 })
-```
-
-The compatible `mediaSpoilerMode` option provides an additional explicit path. Set it to `viewOnce` for supported image, video, document, or sticker media, or set it to `native` to apply the native spoiler context flag. The option is intentionally opt-in and does not change the default behavior of existing applications.
 
-```javascript
 await sock.sendMessage(jid, {
   video: { url: './media/clip.mp4' },
   caption: 'View-once video',
@@ -206,11 +181,16 @@ await sock.sendMessage(jid, {
 })
 ```
 
-The existing `viewOnce`, `viewOnceV2`, `viewOnceV2Extension`, and `spoiler` options remain supported. When an explicit view-once option is enabled, it takes precedence over `mediaSpoilerMode`.
+`mediaSpoilerMode` is an additional, opt-in path for supported image, video, document, or sticker media:
 
-## Rich menu example
+| Value | Effect |
+| --- | --- |
+| `viewOnce` | Wraps supported media in a view-once envelope |
+| `native` | Applies the native spoiler context flag |
+
+The existing `viewOnce`, `viewOnceV2`, `viewOnceV2Extension`, and `spoiler` options remain supported and take precedence over `mediaSpoilerMode` when explicitly set.
 
-The experimental rich-menu helper accepts a header, card rows or a carousel, stable button IDs, and a footer action:
+## Rich menu example
 
 ```javascript
 await sock.richMenu(jid, {
@@ -245,9 +225,21 @@ await sock.richMenu(jid, {
 })
 ```
 
+| Rich menu field | Purpose |
+| --- | --- |
+| `header` | Optional title and image shown above the menu |
+| `body.row` / `body.carousel` | Layout mode for the cards |
+| `body.cards` | Rows of stable button IDs and labels |
+| `footer` | Text plus an optional action URL |
+
 ## Status, grids, tables, and flows
 
-The socket also provides helpers for status posts, status mentions, button grids, interactive tables, and WhatsApp flows:
+| Helper | Purpose |
+| --- | --- |
+| `sendStatus` | Post a status update, optionally with mentions via `statusJidList` |
+| `sendRichButtonGrid` | Send a card grid of stable-ID buttons |
+| `sendInteractiveTable` | Send tabular content with headers, rows, and action buttons |
+| `sendWhatsAppFlow` | Launch a published WhatsApp Flow |
 
 ```javascript
 await sock.sendStatus({ text: 'New Codex status' }, {
@@ -287,14 +279,17 @@ These helpers are protocol- and client-dependent. Use graceful fallbacks when an
 
 ## Authentication and deployment guidance
 
-Authentication data contains sensitive account credentials. Keep the session directory private, exclude it from version control, and use a dedicated service account or restricted filesystem permissions where possible. Do not place access tokens, private keys, phone numbers, or personal account data in the README, package archive, or a public repository.
-
-For production deployments, pin dependencies with a lockfile, use a supported Node.js runtime, monitor connection events, handle logout separately from recoverable disconnects, and keep reconnect logic from creating uncontrolled parallel sockets.
+| Practice | Detail |
+| --- | --- |
+| Session privacy | Keep the session directory private and excluded from version control |
+| Access control | Use a dedicated service account or restricted filesystem permissions where possible |
+| Secrets handling | Do not place access tokens, private keys, phone numbers, or personal account data in the README, package archive, or a public repository |
+| Dependency pinning | Pin dependencies with a lockfile for production deployments |
+| Runtime | Use a supported Node.js runtime |
+| Connection handling | Monitor connection events; handle logout separately from recoverable disconnects; avoid uncontrolled parallel sockets on reconnect |
 
 ## Development workflow
 
-Run the package tests with:
-
 ```bash
 npm test
 ```
@@ -303,33 +298,155 @@ Before submitting changes, validate ESM syntax, CommonJS compatibility where app
 
 ## Recent compatibility updates
 
-The current source includes the verified album compatibility correction: album child messages use association type `1`, the compatible child-association wire value, rather than treating the `MEDIA_ALBUM` message category as the association value.
-
-The source also preserves the package’s explicit view-once implementations and exposes the opt-in `mediaSpoilerMode` path for applications that want either a view-once envelope or a native spoiler context flag without changing existing defaults.
+| Update | Detail |
+| --- | --- |
+| Album association fix | Album child messages use association type `1`, the compatible child-association wire value, rather than treating the `MEDIA_ALBUM` message category as the association value |
+| View-once preserved | Explicit view-once implementations remain unchanged |
+| `mediaSpoilerMode` | New opt-in path for a view-once envelope or native spoiler flag, without altering existing defaults |
 
 ## About Codex
 
 This package is built and maintained by **Codex**, also known as **Dev Codex**. Codex is a developer from Nigeria who focuses on practical, accessible, and reliable software projects across the JavaScript and TypeScript ecosystem.
 
-Codex works with JavaScript, HTML, TypeScript, Node.js, GitHub, Baileys, APIs, key-value stores, and related developer tools. Projects include application development, websites, WhatsApp bots, Telegram bots, API endpoints, and games.
-
-The developer’s work is driven by a commitment to learning, experimentation, clear documentation, and useful software that developers can understand and extend. This package reflects that commitment through its readable source, public declarations, practical examples, and emphasis on responsible automation.
+| | |
+| --- | --- |
+| Tech stack | JavaScript, HTML, TypeScript, Node.js, GitHub, Baileys, APIs, key-value stores |
+| Project types | Application development, websites, WhatsApp bots, Telegram bots, API endpoints, games |
+| Telegram | [@codexverified](https://t.me/codexverified) |
+| Email | codexauthorized@gmail.com |
 
-For updates and direct contact, connect with Codex on Telegram at [@codexverified](https://t.me/codexverified). 
-Email: codexauthorized@gmail.com
+The developer's work is driven by a commitment to learning, experimentation, clear documentation, and useful software that developers can understand and extend. This package reflects that commitment through its readable source, public declarations, practical examples, and emphasis on responsible automation.
 
 ## Package layout
 
-The `lib/` directory contains the JavaScript implementation, supporting utilities, and public TypeScript declarations. `WAProto/` contains generated WhatsApp protocol definitions. `engine-requirements.js` performs installation-time runtime checks. `package.json` contains package metadata, scripts, dependencies, and exports. This `README.md` is the user-facing installation and usage guide.
+| Path | Contents |
+| --- | --- |
+| `lib/` | JavaScript implementation, supporting utilities, public TypeScript declarations |
+| `WAProto/` | Generated WhatsApp protocol definitions |
+| `engine-requirements.js` | Installation-time runtime checks |
+| `package.json` | Package metadata, scripts, dependencies, exports |
+| `README.md` | User-facing installation and usage guide |
 
 ## Security and responsible use
 
-This library interacts with WhatsApp accounts and user communications. Use it only with accounts and data you are authorized to control. Respect WhatsApp’s terms, applicable law, and the privacy expectations of message participants. Avoid unsolicited messaging, protect authentication state, limit access to stored media, and provide clear notice when an application performs automated actions.
+This library interacts with WhatsApp accounts and user communications.
 
-Never commit session files, access tokens, private keys, phone numbers, or other personal information to a public repository. Review installation scripts and optional dependencies before deploying to production, and use pinned dependency versions for repeatable builds.
+| Guideline | Detail |
+| --- | --- |
+| Authorization | Use only with accounts and data you are authorized to control |
+| Compliance | Respect WhatsApp's terms, applicable law, and message participants' privacy expectations |
+| Messaging conduct | Avoid unsolicited messaging |
+| Credential safety | Protect authentication state and never commit session files, tokens, private keys, or personal data to a public repository |
+| Media access | Limit access to stored media |
+| Transparency | Provide clear notice when an application performs automated actions |
+| Dependency review | Review installation scripts and optional dependencies before deploying to production; use pinned versions for repeatable builds |
 
 ## License and maintenance
 
 This distribution is provided under the license declared in `package.json` and the accompanying license file. Review those terms before redistributing or combining this package with third-party code.
 
 **@codexverified/baileys is built and maintained by Codex under the CodexVerified organization.** Contributions, bug reports, and carefully documented improvements are welcome through the project repository.
+
+## Compatibility additions
+
+The current source includes several independently implemented compatibility helpers identified during comparison with the published upstream package. These additions preserve the Codex package identity and do not copy package-specific attribution enforcement or remote licensing checks.
+
+### Copy-to-clipboard rich response
+
+`sendCopyButton` creates a forwarded GenAI-style rich response with a copy-to-clipboard addon action.
+
+| Option | Purpose |
+| --- | --- |
+| `text` | The content that gets copied |
+| `label` | Optional visible button text |
+| `alignment` | `END`, `START`, or `CENTER` |
+
+```javascript
+await sock.sendCopyButton(jid, {
+  text: 'npm install @codexverified/baileys',
+  label: 'Copy install command',
+  alignment: 'END'
+})
+```
+
+As with other private or experimental WhatsApp rich-response layouts, clients may fall back to plain rendering or ignore the addon action.
+
+### Slot-machine HTML generator
+
+`generateSlotMachineHtml` produces a self-contained five-reel Fruit Bonanza game with adjustable starting credits. It is a standalone HTML payload and performs no network requests.
+
+| Option | Purpose |
+| --- | --- |
+| `title` | Display title for the generated page |
+| `startingCredits` | Initial credit balance |
+
+```javascript
+import { generateSlotMachineHtml } from '@codexverified/baileys'
+
+const html = generateSlotMachineHtml({
+  title: 'Codex Fruit Bonanza',
+  startingCredits: 500
+})
+```
+
+The generator does not by itself send HTML through WhatsApp. Applications should only use an HTML-capable message primitive when that primitive is available and authorized for their deployment.
+
+### Optional ban-status checker
+
+`checkStatusWA` is an explicit, caller-invoked diagnostic helper. It is never called during installation, socket creation, reconnection, or message sending. The endpoint is configurable, credentials are not embedded, and callers should review the endpoint's terms and privacy implications before sending a phone number.
+
+```javascript
+import { checkStatusWA } from '@codexverified/baileys'
+
+const result = await checkStatusWA('+447700900123', {
+  diagnostic: true
+})
+console.log(result.status) // active, banned, blocked, not_registered, rate_limited, or unknown
+```
+
+| Status value | Meaning |
+| --- | --- |
+| `active` | Number appears active on WhatsApp |
+| `banned` | Number appears banned |
+| `blocked` | Number appears blocked |
+| `not_registered` | Number is not registered on WhatsApp |
+| `rate_limited` | Check was rate limited |
+| `unknown` | Status could not be determined |
+
+This helper is not an anti-ban guarantee, does not bypass enforcement, and should not be used for bulk enumeration or unsolicited checking.
+
+## Comparison references
+
+The feature comparison was based on the published package metadata and documentation available from [npm][1] and the independent package analysis page at [Socket][2]. The Codex implementation adds compatible behavior through readable, package-owned code rather than copying upstream-specific integrity, attribution, or remote-verification mechanisms.
+
+[1]: https://www.npmjs.com/
+[2]: https://socket.dev/
+
+## Additional functional compatibility helpers
+
+The source also exposes portable helpers for native-flow responses, view-once inspection, rich content preparation, HTML payload construction, and website previews. These are functional compatibility APIs only; package-specific identity checks, attribution enforcement, remote license gates, trusted-channel auto-follow behavior, and other ownership structures are not included.
+
+| Helper | Purpose |
+| --- | --- |
+| `parseNativeFlowResponse` | Normalize quick-reply, single-select, and Flow response envelopes |
+| `parseWhatsAppFlowResponse` | Return only responses identified as WhatsApp Flow responses |
+| `buildWhatsAppFlowButton` / `makeWhatsAppFlowButton` | Build published Flow button parameters for a caller-owned Flow ID and token |
+| `prepareRichTextMessage` | Build a forwarded rich text response |
+| `prepareRichImageMessage` | Build a forwarded rich image response |
+| `prepareRichLinkMessage` | Build a forwarded response with inline link entities |
+| `prepareRichGenerationMessage` | Build a rich response from caller-provided rich content |
+| `prepareHtmlMessage` | Build an HTML primitive payload for clients that support the experimental structure |
+| `prepareSlotMachineMessage` | Wrap the local slot-machine generator as an HTML message payload |
+| `generateLinkPreviewHtml` / `generateWebsitePreviewHtml` | Create escaped link cards or an explicitly requested metadata preview |
+| `parseViewOnceInfo` and related helpers | Inspect, download, reconstruct, and apply explicit view-once policies |
+
+All networked helpers are opt-in. Website previews fetch only when explicitly called, and Flow helpers require credentials and identifiers owned by the application. Experimental WhatsApp layouts remain client-dependent and should always have a plain-text fallback.
+
+## AI generation primitive
+
+`buildImaginePrimitive` creates the Meta-style AI image or animation generation-state payload used by rich responses. It is a pure payload builder — it does not call a generation service itself, generate media, or send anything on its own; callers wire it up to whatever AI generation backend they use, then pass the resulting primitive into a rich-response message.
+
+| Field | Purpose |
+| --- | --- |
+| `state` | Generation status: `GENERATING`, `COMPLETE`, or `ERROR` |
+| `mediaUrl` | URL of the generated media

package/lib/Socket/index.js

@@ -36,7 +36,7 @@ const makeWASocket = (config) => {
         };
         console.log(
             `\n${yellow}${center('CODEX TECHNOLOGY')}${reset}\n` +
-            `${blue}${center('@codexverified/Baileys')}${reset}\n` +
+            `${blue}${center('@codexverified/baileys')}${reset}\n` +
             `${yellow}${center('premium baileys built by codex')}${reset}\n`
         );
     }

package/lib/Socket/messages-send.js

@@ -16,7 +16,7 @@ import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID }
 import { makeUsernameSocket } from './username.js';
 
 const STATUS_JID = 'status@broadcast';
-const normalizeStatusJidList = (value) => {
+export const normalizeStatusJidList = (value) => {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Boom('statusJidList must contain at least one recipient JID', { statusCode: 400 });
     }
@@ -1223,6 +1223,13 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
             return fullMsg;
         },
+        sendCopyButton: async (jid, content = {}, options = {}) => {
+            const { prepareCopyToClipboardMessage } = await import('../Utils/rich-message-utils.js');
+            const message = prepareCopyToClipboardMessage(content);
+            const fullMsg = await generateWAMessageFromContent(jid, message, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+            await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
+            return fullMsg;
+        },
         sendInteractiveTable: async (jid, table, options = {}) => {
             const { title = '', headers = [], rows = [], image, buttons = [], footer } = table || {};
             if (!Array.isArray(headers) || !Array.isArray(rows) || !Array.isArray(buttons)) throw new Boom('sendInteractiveTable expects headers, rows, and buttons arrays', { statusCode: 400 });

package/lib/Utils/ban-checker.js

@@ -0,0 +1,48 @@
+/**
+ * Optional WhatsApp registration-status checker.
+ *
+ * This module is deliberately opt-in. It does not run during installation,
+ * connection setup, or message sending, and it does not contain credentials.
+ * Callers should review the endpoint and applicable terms before use.
+ */
+
+const cleanNumber = (value) => String(value ?? '').replace(/[\s().\-/]/g, '').replace(/^00/, '').replace(/^\+/, '');
+
+export const normalizeBanCheckNumber = (value) => {
+    const number = cleanNumber(typeof value === 'object' ? value.number : value);
+    if (!/^\d{6,15}$/.test(number)) throw new TypeError('number must be an international phone number');
+    return `+${number}`;
+};
+
+export const checkStatusWA = async (number, options = {}) => {
+    const normalized = normalizeBanCheckNumber(number);
+    const endpoint = options.endpoint || 'https://v.whatsapp.net/v2/exist';
+    const fetchImpl = options.fetch || globalThis.fetch;
+    if (typeof fetchImpl !== 'function') throw new TypeError('a fetch implementation is required');
+    const url = new URL(endpoint);
+    url.searchParams.set('in', normalized.slice(1));
+    const response = await fetchImpl(url, {
+        method: 'GET',
+        headers: { ...(options.headers || {}) },
+        signal: options.signal
+    });
+    let body = null;
+    try { body = await response.json(); } catch { body = null; }
+    const reason = String(body?.reason || body?.error || body?.status || '').toLowerCase();
+    let status = 'unknown';
+    if (response.status === 429 || /rate.?limit|too many/.test(reason)) status = 'rate_limited';
+    else if (/blocked|official|banned|ban|temporar|perman/.test(reason)) status = /banned|ban|temporar|perman/.test(reason) ? 'banned' : 'blocked';
+    else if (/not.?registered|does.?not.?exist/.test(reason)) status = 'not_registered';
+    else if (response.ok) status = 'active';
+    return {
+        number: normalized,
+        status,
+        isBanned: status === 'banned',
+        isNeedOfficialWa: status === 'blocked',
+        diagnostics: options.diagnostic === true ? {
+            httpStatus: response.status,
+            ok: response.ok,
+            bodyKeys: body && typeof body === 'object' ? Object.keys(body).sort() : []
+        } : undefined
+    };
+};

package/lib/Utils/games/slot-machine.js

@@ -0,0 +1,19 @@
+/**
+ * Self-contained, dependency-free slot-machine HTML generator.
+ * The generated page is local-only and makes no network requests.
+ */
+
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>"']/g, (character) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+}[character]));
+
+export const generateSlotMachineHtml = (options = {}) => {
+    const title = escapeHtml(options.title || 'FRUIT BONANZA');
+    const startingCredits = Number.isFinite(Number(options.startingCredits)) && Number(options.startingCredits) >= 0
+        ? Math.floor(Number(options.startingCredits)) : 500;
+    return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><style>
+*{box-sizing:border-box}body{margin:0;padding:12px;background:#160704;color:#ffe8a3;font:14px system-ui,sans-serif}.machine{max-width:540px;margin:auto;padding:16px;border:4px solid #e6a139;border-radius:22px;background:linear-gradient(135deg,#230805,#8c3515,#2b0906);box-shadow:0 8px 18px #000a}.title{text-align:center;font-size:24px;font-weight:900;color:#fff2a1;text-shadow:0 2px #8f1c0c}.stats{display:flex;justify-content:space-around;margin:10px 0;padding:8px;border:2px solid #a55c19;border-radius:8px;background:#100303}.reels{display:grid;grid-template-columns:repeat(5,1fr);gap:5px;padding:8px;border:5px solid #9b4e12;border-radius:14px;background:#140604}.reel{height:78px;display:grid;place-items:center;border-radius:6px;background:linear-gradient(#fffce4,#d7bf87);color:#b20f1c;font-size:38px;font-weight:900;overflow:hidden}.reel.spin{animation:spin .16s linear infinite}.message{min-height:30px;margin:10px;text-align:center;font-weight:800}.controls{display:flex;gap:8px}.controls button{flex:1;padding:12px;border:2px solid #351006;border-radius:10px;font-weight:900;cursor:pointer}.bet{background:#1685a5;color:white}.spin{background:#27a93b;color:white}.spin:disabled{opacity:.5}@keyframes spin{50%{transform:translateY(5px);filter:blur(1px)}}small{display:block;margin-top:10px;text-align:center;color:#d6a15b}</style></head><body><main class="machine"><div class="title">${title}</div><div class="stats"><span>Credits <b id="credits">${startingCredits}</b></span><span>Bet <b id="bet">10</b></span><span>Best <b id="best">0</b></span></div><div class="reels">${[0,1,2,3,4].map((index) => `<div class="reel" id="r${index}">🍒</div>`).join('')}</div><div class="message" id="message">SPIN TO PLAY</div><div class="controls"><button class="bet" id="betButton" type="button">BET</button><button class="spin" id="spinButton" type="button">SPIN</button></div><small>Three matching symbols win. This is a local chat-embedded game.</small></main><script>
+(()=>{const symbols=['🍒','🍋','🔔','💎','7️⃣','🅱️'];let credits=${startingCredits},bet=10,best=0,busy=false;const $=id=>document.getElementById(id);const ui=()=>{$('credits').textContent=credits;$('bet').textContent=bet;$('best').textContent=best};$('betButton').onclick=()=>{if(busy)return;bet=bet===10?20:bet===20?50:10;if(bet>credits)bet=10;ui()};$('spinButton').onclick=()=>{if(busy||credits<bet)return;busy=true;credits-=bet;$('message').textContent='GOOD LUCK';ui();const reels=[0,1,2,3,4].map(i=>$('r'+i));reels.forEach(r=>r.classList.add('spin'));setTimeout(()=>{const values=reels.map(r=>{r.classList.remove('spin');const value=symbols[Math.floor(Math.random()*symbols.length)];r.textContent=value;return value});const counts=values.reduce((map,value)=>(map[value]=(map[value]||0)+1,map),{});const match=Math.max(...Object.values(counts));const win=match>=3?bet*(match===5?20:match===4?8:3):0;credits+=win;best=Math.max(best,win);$('message').textContent=win?'WIN +'+win:(credits?'TRY AGAIN':'GAME OVER');busy=false;ui()},700)};ui()})();</script></body></html>`;
+};
+
+export default generateSlotMachineHtml;

package/lib/Utils/index.js

@@ -32,3 +32,9 @@ export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
+export * from './games/slot-machine.js';
+export * from './ban-checker.js';
+export * from './native-flow.js';
+export * from './view-once-utils.js';
+export * from './website-preview.js';
+export * from './portable-compat.js';

package/lib/Utils/native-flow.js

@@ -0,0 +1,48 @@
+const parseJsonObject = (value) => {
+    if (!value) return {};
+    if (typeof value === 'object') return value;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch { return {}; }
+};
+
+export const parseNativeFlowResponse = (message) => {
+    const content = message?.message || message;
+    const response = content?.interactiveResponseMessage?.nativeFlowResponseMessage || content?.nativeFlowResponseMessage;
+    if (!response) return null;
+    const params = parseJsonObject(response.paramsJson);
+    const actionPayload = params.flow_action_payload || params.flowActionPayload || {};
+    const data = params.data || params.response || params.form_data || params.formData || actionPayload.data || {};
+    return {
+        name: response.name || '', version: response.version, paramsJson: response.paramsJson || '', params,
+        isFlow: response.name === 'galaxy_message' || response.name === 'flow' || Boolean(params.flow_id || params.flow_token || params.flow_message_version),
+        flowId: params.flow_id || params.flowId, flowToken: params.flow_token || params.flowToken,
+        screen: params.screen || actionPayload.screen, action: params.flow_action || params.flowAction || actionPayload.action,
+        actionPayload, data, buttonId: params.id || params.button_id || params.buttonId,
+        displayText: params.display_text || params.displayText, raw: response
+    };
+};
+
+export const parseWhatsAppFlowResponse = (message) => {
+    const response = parseNativeFlowResponse(message);
+    return response?.isFlow ? response : null;
+};
+
+export const buildWhatsAppFlowButton = ({ flowId, flowToken, cta = 'Open form', action = 'navigate', actionPayload, mode = 'published', flowMessageVersion = '3', metadata, name = 'galaxy_message' } = {}) => {
+    if (!flowId) throw new TypeError('flowId is required to launch a WhatsApp Flow');
+    if (!flowToken) throw new TypeError('flowToken is required to launch a WhatsApp Flow');
+    return {
+        name, flow_message_version: String(flowMessageVersion), flow_token: String(flowToken), flow_id: String(flowId),
+        flow_cta: String(cta), flow_action: action,
+        ...(actionPayload ? { flow_action_payload: actionPayload } : {}),
+        ...(metadata ? { flow_metadata: metadata } : {}),
+        ...(mode ? { flow_mode: String(mode) } : {})
+    };
+};
+
+export const makeWhatsAppFlowButton = (flow) => ({
+    name: flow?.nativeFlowName || 'galaxy_message',
+    buttonParamsJson: JSON.stringify(buildWhatsAppFlowButton(flow))
+});
+      

package/lib/Utils/portable-compat.js

@@ -0,0 +1,12 @@
+import { generateRichMenuContent } from './message-composer.js';
+import { prepareRichResponseMessage } from './rich-message-utils.js';
+
+/** Build a prepared rich-menu payload for direct message generation. */
+export const prepareRichMenuMessage = (content = {}, quoted, options = {}) => generateRichMenuContent(content, quoted, options);
+
+/** Convert unsupported premium content to a safe plain-text rich response. */
+export const downgradePremiumContent = (content = {}) => {
+    if (typeof content === 'string') return prepareRichResponseMessage({ contentText: content, noDonation: true });
+    const text = content.text || content.contentText || content.caption || '';
+    return prepareRichResponseMessage({ contentText: String(text), noDonation: true });
+};

package/lib/Utils/rich-message-utils.js

@@ -299,7 +299,7 @@ export const prepareRichResponseMessage = (content) => {
         const defaultDonationLink = {
             text: '',
             url: DONATE_URL,
-            title: 'PAIR CRYSNVA AI :',
+            title: 'PAIR CODEX AI :',
             displayName: 'pair bot'
         };
         const resolvedLinks = noDonation ? links : [...(links || []), defaultDonationLink];
@@ -436,4 +436,110 @@ export const wrapToBotForwardedMessage = (richResponseMessage) => ({
         message: { richResponseMessage }
     }
 });
-//# sourceMappingURL=rich-message-utils.js.map
+//# sourceMappingURL=rich-message-utils.js.map
+
+/**
+ * Build a forwarded rich response with an inline copy-to-clipboard action.
+ * The payload follows WhatsApp's GenAI addon-action layout and is opt-in.
+ * @param {{text?: string, label?: string, alignment?: 'END'|'START'|'CENTER'}} options
+ * @returns {{messageContextInfo: object, botForwardedMessage: object}}
+ */
+export const prepareCopyToClipboardMessage = (options = {}) => {
+    const text = String(options.text ?? '');
+    const label = String(options.label ?? text);
+    const alignment = ['END', 'START', 'CENTER'].includes(options.alignment) ? options.alignment : 'END';
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAIAddonActionLayoutViewModel',
+                addon_action_type: 'COPY_TO_CLIPBOARD',
+                addon_action_alignment: alignment,
+                primitives: [{
+                    __typename: 'GenAIMarkdownTextUXPrimitive',
+                    text: label,
+                    inline_entities: []
+                }]
+            }
+        }]
+    };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
+/** Build a plain rich-text forwarded response. */
+export const prepareRichTextMessage = ({ text = '' } = {}) => prepareRichResponseMessage({ contentText: String(text), noDonation: true });
+
+/** Build a rich image forwarded response using a GenAI image primitive. */
+export const prepareRichImageMessage = ({ url = '', mimeType = 'image/png' } = {}) => {
+    const media = { __typename: 'GenAIMediaItem', mime_type: mimeType, url: String(url), url_fallback: String(url) };
+    const unified = { response_id: randomUUID(), sections: [{ __typename: 'GenAIUnifiedResponseSection', view_model: { __typename: 'GenAISingleLayoutViewModel', primitive: { __typename: 'GenAIImagePrimitive', preview_image: media, full_image: media } } }] };
+    const rich = proto.AIRichResponseMessage.create({ submessages: [], messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD, unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 } });
+    return wrapToBotForwardedMessage(rich);
+};
+
+/** Build a rich response containing clickable inline links. */
+export const prepareRichLinkMessage = ({ links = [], text = '' }= {}) => {
+    const entities = [];
+    let combined = '';
+    for (const [index, link] of links.entries()) {
+        const key = `INLINE_HYPERLINK_${index}`;
+        const display = String(link?.text || link?.displayName || link?.url || '');
+        combined += `{{${key}}}${display}{{/${key}}}`;
+        entities.push({ key, metadata: { display_name: display, is_trusted: link?.isTrusted !== false, url: String(link?.url || ''), __typename: 'GenAIInlineLinkItem' } });
+    }
+    return prepareRichResponseMessage({ contentText: combined || String(text), links: [], noDonation: true, noHeading: true, richResponse: [{ text: combined || String(text), inlineEntities: entities }] });
+};
+
+/** Build a rich-generation response from existing rich-response content. */
+export const prepareRichGenerationMessage = (content = {}) => prepareRichResponseMessage({ ...content, noDonation: true });
+
+/** Build an HTML primitive payload. Use only with an HTML-capable, authorized client. */
+export const prepareHtmlMessage = ({ html = '' } = {}) => {
+    const unified = { response_id: randomUUID(), sections: [{ view_model: { primitive: { __typename: 'FOAHtmlPrimitiveDemoDONOTUSE', html: String(html) }, __typename: 'GenAISingleLayoutViewModel' } }] };
+    const rich = proto.AIRichResponseMessage.create({ submessages: [], messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD, unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 } });
+    return wrapToBotForwardedMessage(rich);
+};
+
+/** Convenience wrapper for a slot-machine HTML message payload. */
+export const prepareSlotMachineMessage = async (options = {}) => {
+    const { generateSlotMachineHtml } = await import('./games/slot-machine.js');
+    return prepareHtmlMessage({ html: generateSlotMachineHtml(options) });
+};
+
+/**
+ * Build a Meta-style AI image/video generation primitive.
+ * The payload is useful for displaying generation progress without making any
+ * network request or enabling a hidden background process.
+ */
+export const buildImaginePrimitive = ({
+    mediaType = 'video',
+    url = '',
+    thumbnail,
+    mimeType,
+    fileLength = 0,
+    duration = 0,
+    status = 'GENERATING',
+    estimatedMs,
+    imagineType
+} = {}) => {
+    const normalizedType = String(mediaType).toLowerCase() === 'image' ? 'IMAGE' : 'ANIMATE';
+    return {
+        __typename: 'GenAIImaginePrimitive',
+        media_type: normalizedType,
+        imagine_type: imagineType || normalizedType,
+        status: String(status),
+        ...(url ? { url: String(url), url_fallback: String(url) } : {}),
+        ...(thumbnail ? { thumbnail_url: String(thumbnail) } : {}),
+        ...(mimeType ? { mime_type: String(mimeType) } : {}),
+        ...(fileLength ? { file_length: Number(fileLength) } : {}),
+        ...(duration ? { duration: Number(duration) } : {}),
+        ...(estimatedMs !== undefined ? { estimated_ms: Number(estimatedMs) } : {})
+    };
+};

package/lib/Utils/view-once-utils.js

@@ -0,0 +1,56 @@
+import { downloadContentFromMessage } from './messages-media.js';
+
+export const isViewOnceMessage = (message) => Boolean(message?.message?.viewOnceMessage || message?.message?.viewOnceMessageV2 || message?.message?.viewOnceMessageV2Extension || message?.viewOnceMessage || message?.viewOnceMessageV2 || message?.viewOnceMessageV2Extension);
+
+export const extractViewOnceContent = (message) => {
+    const content = message?.message || message;
+    return content?.viewOnceMessage?.message || content?.viewOnceMessageV2?.message || content?.viewOnceMessageV2Extension?.message || null;
+};
+
+export const getViewOnceMediaType = (message) => {
+    const content = extractViewOnceContent(message);
+    if (!content) return null;
+    for (const type of ['image', 'video', 'audio', 'document', 'sticker']) if (content[`${type}Message`]) return type;
+    return null;
+};
+
+export const getViewOnceMediaContent = (message) => {
+    const content = extractViewOnceContent(message);
+    if (!content) return null;
+    return content.imageMessage || content.videoMessage || content.audioMessage || content.documentMessage || content.stickerMessage || null;
+};
+
+export const downloadViewOnceMedia = async (message, options = {}) => {
+    const media = getViewOnceMediaContent(message);
+    const type = getViewOnceMediaType(message);
+    if (!media || !type) throw new Error('No supported media content found in view-once message');
+    const stream = await downloadContentFromMessage(media, type, options);
+    const chunks = [];
+    for await (const chunk of stream) chunks.push(chunk);
+    return Buffer.concat(chunks);
+};
+
+export const createRegularMessageFromViewOnce = (originalMessage, mediaBuffer) => {
+    const media = getViewOnceMediaContent(originalMessage);
+    const type = getViewOnceMediaType(originalMessage);
+    if (!media || !type) return null;
+    return {
+        key: originalMessage.key, messageTimestamp: originalMessage.messageTimestamp,
+        pushName: originalMessage.pushName, participant: originalMessage.participant,
+        decryptedMedia: { type, buffer: mediaBuffer, mimeType: media.mimetype, fileName: media.fileName, caption: media.caption, fileLength: media.fileLength },
+        originalViewOnceMessage: originalMessage.message
+    };
+};
+
+export const shouldAutoDecryptViewOnce = (message, config = {}) => isViewOnceMessage(message) && config.autoVV !== false && message.key?.fromMe !== true;
+export const shouldDeleteViewOnce = (message, config = {}) => isViewOnceMessage(message) && config.antiVV !== false && message.key?.fromMe !== true;
+
+export const parseViewOnceInfo = (message) => {
+    const media = getViewOnceMediaContent(message);
+    return {
+        isViewOnce: isViewOnceMessage(message), mediaType: getViewOnceMediaType(message), mimeType: media?.mimetype,
+        fileName: media?.fileName, caption: media?.caption, fileLength: media?.fileLength,
+        hasUrl: Boolean(media?.url), hasDirectPath: Boolean(media?.directPath), hasMediaKey: Boolean(media?.mediaKey)
+    };
+};
+  

package/lib/Utils/website-preview.js

@@ -0,0 +1,27 @@
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[character]));
+
+const validateUrl = (value) => {
+    const parsed = new URL(value);
+    if (!['http:', 'https:'].includes(parsed.protocol)) throw new TypeError('only HTTP(S) preview URLs are supported');
+    return parsed;
+};
+
+export const generateLinkPreviewHtml = (url, options = {}) => {
+    const parsed = validateUrl(url);
+    const title = options.title || parsed.hostname;
+    const description = options.description || `Open ${parsed.hostname}`;
+    const image = options.image ? `<img src="${escapeHtml(options.image)}" alt="" loading="lazy">` : '<div class="placeholder">🌐</div>';
+    return `<!doctype html><html><head><meta charset="utf-8"><style>body{margin:0;background:transparent;font:14px system-ui,sans-serif}.card{overflow:hidden;border:1px solid #333;border-radius:12px;background:#1a1a2e;color:#fff}.card img,.placeholder{display:block;width:100%;height:160px;object-fit:cover}.placeholder{display:grid;place-items:center;font-size:48px;background:linear-gradient(135deg,#1a1a2e,#2d2d44)}.body{padding:14px}.title{font-weight:700;margin-bottom:5px}.desc{color:#bbb;line-height:1.4}.url{margin-top:8px;color:#55c878;font-size:11px}</style></head><body><a href="${escapeHtml(parsed.href)}" target="_blank" rel="noopener noreferrer" style="text-decoration:none"><div class="card">${image}<div class="body"><div class="title">${escapeHtml(title)}</div><div class="desc">${escapeHtml(description)}</div><div class="url">${escapeHtml(parsed.hostname)}</div></div></div></a></body></html>`;
+};
+
+export const generateWebsitePreviewHtml = async (url, options = {}) => {
+    const parsed = validateUrl(url);
+    const response = await (options.fetch || globalThis.fetch)(parsed.href, { signal: options.signal, headers: options.headers || {} });
+    if (!response?.ok) throw new Error(`website preview request failed with status ${response?.status ?? 'unknown'}`);
+    const html = await response.text();
+    const title = html.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1] || parsed.hostname;
+    const description = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']*)["']/i)?.[1] || `Preview of ${parsed.hostname}`;
+    return generateLinkPreviewHtml(parsed.href, { ...options, title, description });
+};
+
+export default generateWebsitePreviewHtml;

package/lib/index.d.ts

@@ -259,6 +259,8 @@ export interface WASocket {
     richMenu(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a rich button-card grid. */
     sendRichButtonGrid(jid: string, grid: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a GenAI-style inline copy-to-clipboard rich response. */
+    sendCopyButton(jid: string, content: { text: string; label?: string; alignment?: 'END' | 'START' | 'CENTER' }, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a markdown-style interactive table with buttons. */
     sendInteractiveTable(jid: string, table: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a WhatsApp native flow button. */
@@ -293,6 +295,37 @@ export declare function makeCacheManagerAuthState(store: CacheManagerStore, sess
     saveCreds: () => Promise<void>;
 }>;
 
+/** Generate a self-contained local slot-machine HTML payload. */
+export declare function generateSlotMachineHtml(options?: { title?: string; startingCredits?: number }): string;
+export declare function buildImaginePrimitive(options?: { mediaType?: 'image' | 'video'; url?: string; thumbnail?: string; mimeType?: string; fileLength?: number; duration?: number; status?: string; estimatedMs?: number; imagineType?: string }): Record<string, unknown>;
+export declare function parseNativeFlowResponse(message: unknown): Record<string, unknown> | null;
+export declare function parseWhatsAppFlowResponse(message: unknown): Record<string, unknown> | null;
+export declare function buildWhatsAppFlowButton(flow?: Record<string, unknown>): Record<string, unknown>;
+export declare function makeWhatsAppFlowButton(flow?: Record<string, unknown>): { name: string; buttonParamsJson: string };
+export declare function isViewOnceMessage(message: unknown): boolean;
+export declare function extractViewOnceContent(message: unknown): Record<string, unknown> | null;
+export declare function getViewOnceMediaType(message: unknown): string | null;
+export declare function getViewOnceMediaContent(message: unknown): Record<string, unknown> | null;
+export declare function parseViewOnceInfo(message: unknown): Record<string, unknown>;
+export declare function shouldAutoDecryptViewOnce(message: unknown, config?: Record<string, unknown>): boolean;
+export declare function shouldDeleteViewOnce(message: unknown, config?: Record<string, unknown>): boolean;
+export declare function generateLinkPreviewHtml(url: string, options?: Record<string, unknown>): string;
+export declare function generateWebsitePreviewHtml(url: string, options?: Record<string, unknown>): Promise<string>;
+export declare function prepareRichTextMessage(options?: { text?: string }): Record<string, unknown>;
+export declare function prepareRichImageMessage(options?: { url?: string; mimeType?: string }): Record<string, unknown>;
+export declare function prepareRichLinkMessage(options?: { links?: Array<Record<string, unknown>>; text?: string }): Record<string, unknown>;
+export declare function prepareRichGenerationMessage(content?: Record<string, unknown>): Record<string, unknown>;
+export declare function prepareHtmlMessage(options?: { html?: string }): Record<string, unknown>;
+export declare function prepareSlotMachineMessage(options?: { title?: string; startingCredits?: number }): Promise<Record<string, unknown>>;
+export declare function prepareRichMenuMessage(content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function downgradePremiumContent(content?: unknown): Record<string, unknown>;
+
+/** Normalize an international phone number for an explicit status check. */
+export declare function normalizeBanCheckNumber(value: string | { number: string }): string;
+
+/** Perform an explicit, caller-configured WhatsApp registration-status check. */
+export declare function checkStatusWA(number: string | { number: string }, options?: { endpoint?: string; fetch?: typeof fetch; headers?: Record<string, string>; signal?: AbortSignal; diagnostic?: boolean }): Promise<{ number: string; status: string; isBanned: boolean; isNeedOfficialWa: boolean; diagnostics?: { httpStatus: number; ok: boolean; bodyKeys: string[] } }>;
+
 /** Wrap a socket with anti-ban protection (from the baileys-antiban bundle). */
 export declare function wrapSocket(socket: WASocket, config?: unknown): WASocket;
 

package/lib/index.js

@@ -1,4 +1,5 @@
 import makeWASocket from './Socket/index.js';
+export { normalizeStatusJidList } from './Socket/messages-send.js';
 export * from '../WAProto/index.js';
 export * from './Utils/index.js';
 export * from './Types/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.10.12",
+   "version": "2.11.12",
    "description": "CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex, with Meta compositing, bot planning replay, welcome flow, rich messages, interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",