@japofc/baileys 2.1.0

package/engine-requirements.js

@@ -0,0 +1,13 @@
+const major = parseInt(
+    process.versions.node.split('.')[0],
+    10
+);
+
+if (major < 20) {
+    console.error(
+        `\n❌ This package requires Node.js 20+ to run reliably.\n` +
+        `   You are using Node.js ${process.versions.node}.\n` +
+        `   Please upgrade to Node.js 20+ to proceed.\n`
+    );
+    process.exit(1);
+}

package/lib/Builders/A2UI.d.ts

@@ -0,0 +1,242 @@
+/**
+ * A2UI/Bloks "basic" catalog node types — confirmed from captured traffic, not a
+ * public spec, so treat this as best-effort autocomplete rather than an
+ * exhaustive guarantee. `ref` is a builder-only tag (stripped before send) so
+ * another node can reference this one via `BloksRef`.
+ */
+export interface BloksRef {
+    $ref: string;
+}
+export interface BloksNodeBase {
+    /** Builder-only tag so another node can reference this one via `{ $ref: ref }`. Stripped before send. */
+    ref?: string;
+}
+export interface ColumnRowNode extends BloksNodeBase {
+    component: 'Column' | 'Row';
+    weight?: number;
+    justify?: string;
+    children?: BloksNode[];
+}
+export interface TextNode extends BloksNodeBase {
+    component: 'Text';
+    text: string;
+    variant?: string;
+}
+export interface IconNode extends BloksNodeBase {
+    component: 'Icon';
+    name: string;
+}
+export interface DividerNode extends BloksNodeBase {
+    component: 'Divider';
+}
+export interface ImageNode extends BloksNodeBase {
+    component: 'Image';
+    url: string;
+    variant?: string;
+    fit?: string;
+}
+export interface VideoNode extends BloksNodeBase {
+    component: 'Video';
+    url: string;
+}
+export interface ListNode extends BloksNodeBase {
+    component: 'List';
+    children?: BloksNode[];
+}
+export interface TextFieldNode extends BloksNodeBase {
+    component: 'TextField';
+    label?: string;
+    value?: string;
+    variant?: string;
+}
+export interface DateTimeInputNode extends BloksNodeBase {
+    component: 'DateTimeInput';
+    label?: string;
+    value?: string;
+    enableDate?: boolean;
+    enableTime?: boolean;
+}
+export interface SliderNode extends BloksNodeBase {
+    component: 'Slider';
+    label?: string;
+    min?: number;
+    max?: number;
+    value?: number;
+}
+export interface SwitchNode extends BloksNodeBase {
+    component: 'Switch';
+    label?: string;
+    value?: boolean;
+}
+export interface CheckBoxNode extends BloksNodeBase {
+    component: 'CheckBox';
+    label?: string;
+    value?: boolean;
+}
+export interface ChoicePickerNode extends BloksNodeBase {
+    component: 'ChoicePicker';
+    label?: string;
+    variant?: string;
+    displayStyle?: string;
+    options?: Array<{ label: string; value: string }>;
+    value?: string;
+}
+/**
+ * Unlike the CTA/native-flow `Button` class elsewhere, an A2UI Button node has no
+ * `label`/`type`+`name` — its label comes from a nested `child` (usually a `Text` node), and
+ * tapping it fires `action.call` (with `action.args`), not a native-flow button name.
+ */
+export interface BloksButtonNode extends BloksNodeBase {
+    component: 'Button';
+    child?: BloksNode;
+    variant?: string;
+    action?: { call: string; args?: Record<string, any> };
+}
+export interface ModalNode extends BloksNodeBase {
+    component: 'Modal';
+    trigger: string | BloksRef;
+    content: BloksNode | string | BloksRef;
+}
+export interface TabsNode extends BloksNodeBase {
+    component: 'Tabs';
+    tabs: Array<{ title: string; child: BloksNode }>;
+}
+export interface CardNode extends BloksNodeBase {
+    component: 'Card';
+    child?: BloksNode;
+}
+export interface ProgressBarNode extends BloksNodeBase {
+    component: 'ProgressBar';
+    value?: number;
+    min?: number;
+    max?: number;
+    variant?: string;
+}
+export interface AvatarNode extends BloksNodeBase {
+    component: 'Avatar';
+    url?: string;
+    variant?: string;
+    size?: number;
+}
+export interface BadgeNode extends BloksNodeBase {
+    component: 'Badge';
+    child?: string | BloksNode;
+    label?: string;
+}
+export interface SpacerNode extends BloksNodeBase {
+    component: 'Spacer';
+    height?: number;
+}
+export interface AudioPlayerNode extends BloksNodeBase {
+    component: 'AudioPlayer';
+    url: string;
+    description?: string;
+}
+/** Fallback for components not yet confirmed on the wire — still works at runtime, just no prop-level autocomplete. */
+export interface AnyBloksNode extends BloksNodeBase {
+    component: string;
+    [key: string]: any;
+}
+export type BloksNode =
+    | ColumnRowNode
+    | TextNode
+    | IconNode
+    | DividerNode
+    | ImageNode
+    | VideoNode
+    | ListNode
+    | TextFieldNode
+    | DateTimeInputNode
+    | SliderNode
+    | SwitchNode
+    | CheckBoxNode
+    | ChoicePickerNode
+    | BloksButtonNode
+    | ModalNode
+    | TabsNode
+    | CardNode
+    | ProgressBarNode
+    | AvatarNode
+    | BadgeNode
+    | SpacerNode
+    | AudioPlayerNode
+    | AnyBloksNode;
+
+export interface A2UIBuilderOptions {
+    catalogId?: string;
+    version?: string;
+}
+
+export interface A2UIBuildOptions {
+    uuid?: string;
+    surfaceId?: string;
+    type?: string;
+    wrapped?: boolean;
+}
+
+export interface A2UIBuildResult {
+    uuid: string;
+    data: string;
+    type: string;
+}
+
+export interface ListCardOptions {
+    title?: string;
+    items?: any[];
+    fallbackText?: string;
+    uuid?: string;
+}
+
+export interface SendA2UIWidgetOptions {
+    a2ui: A2UI;
+    bodyText?: string;
+    footer?: string;
+    buttons?: any[];
+    contextInfo?: Record<string, any>;
+    expiration?: number;
+    quoted?: any;
+    type?: string;
+    wrapped?: boolean;
+    singleScreen?: boolean;
+    header?: {
+        title?: string;
+        subtitle?: string;
+        image?: string | Buffer | { url: string };
+        video?: string | Buffer | { url: string };
+        document?: string | Buffer | { url: string };
+    };
+}
+
+/** Fluent A2UI/Bloks widget builder. All widget methods return `this`; refs validated at build(). */
+export class A2UI {
+    constructor(options?: A2UIBuilderOptions);
+    text(text: string, options?: { id?: string; variant?: string }): this;
+    image(url: string, options?: { id?: string; variant?: string; fit?: string }): this;
+    video(url: string, options?: { id?: string }): this;
+    checkbox(label: string, options?: { id?: string; value?: boolean }): this;
+    textField(label: string, options?: { id?: string; variant?: string }): this;
+    button(childId: string, options?: { id?: string; variant?: string; action?: { call: string; args?: Record<string, any> } }): this;
+    card(childId: string, options?: { id?: string }): this;
+    modal(triggerId: string, contentId: string, options?: { id?: string }): this;
+    raw(component: string, props?: Record<string, any>, options?: { id?: string }): this;
+    column(children?: string[], options?: { id?: string }): this;
+    row(children?: string[], options?: { id?: string }): this;
+    divider(options?: { id?: string }): this;
+    slider(options?: { id?: string; value?: number; min?: number; max?: number; step?: number; label?: string }): this;
+    switch(label: string, options?: { id?: string; value?: boolean }): this;
+    list(children?: string[], options?: { id?: string }): this;
+    progressBar(value: number, options?: { id?: string; min?: number; max?: number; variant?: string }): this;
+    avatar(url: string, options?: { id?: string; variant?: string; size?: number }): this;
+    badge(childId: string, options?: { id?: string; label?: string }): this;
+    spacer(options?: { id?: string; height?: number }): this;
+    tabs(children?: string[], options?: { id?: string; activeTab?: number }): this;
+    choicePicker(label: string, options: Array<{ label: string; value: string }>, opts?: { id?: string; variant?: string; value?: string; displayStyle?: string; filterable?: boolean }): this;
+    root(children: string[]): this;
+    listCard(options?: ListCardOptions): this;
+    send(client: any, jid: string, opts?: Record<string, any>): Promise<any>;
+    /** Validates refs, then returns the serialised widget payload. Call root() first (unless listCard()). */
+    build(options?: A2UIBuildOptions): A2UIBuildResult;
+}
+
+/** Build + send an A2UI/Bloks widget as an interactiveMessage. */
+export declare const sendA2UIWidget: (client: any, jid: string, options?: SendA2UIWidgetOptions) => Promise<any>;

package/lib/Builders/A2UI.js

@@ -0,0 +1,308 @@
+/**
+ * lib/Builders/A2UI.js — A2UI (Bloks) widget builder + sender
+ *
+ * Part of @japofc/baileys. Builds the flat `components` array A2UI/Bloks
+ * expects (id-referencing tree: Column/Row hold `children`, Card/Button hold
+ * `child`, Modal holds `trigger`/`content`) and sends it as an
+ * `interactiveMessage.bloksWidget` via the same `getBizBinaryNode()` path
+ * Button/ButtonV2 use, so the wire-level <biz>/<native_flow> node always
+ * matches the actual button names sent — no more hand-rolled duplicate of
+ * that logic living outside the library.
+ *
+ * See MessageBuilder.js's `Button.setBloksWidget()` for the declarative
+ * (nested-tree) alternative to this imperative (id-returning-factory) API;
+ * both produce the same wire format and can be mixed freely.
+ */
+"use strict";
+
+import crypto from "crypto";
+import { generateWAMessageFromContent, prepareWAMessageMedia } from "../Utils/messages.js";
+import { getBizBinaryNode } from "../WABinary/index.js";
+
+class A2UI {
+	constructor({ catalogId = "https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json", version = "v0.9" } = {}) {
+		this._version = version;
+		this._catalogId = catalogId;
+		this._components = new Map();
+		this._counter = 0;
+		this._rootChildren = [];
+	}
+	#nextId(prefix) {
+		return `${prefix}_${(this._counter++).toString(36)}`;
+	}
+	#reg(id, component, extra = {}) {
+		id ??= this.#nextId(component.toLowerCase());
+		if (id === "root") throw new Error(`Component id "root" is reserved for the implicit root wrapper`);
+		if (this._components.has(id)) throw new Error(`Component id "${id}" already used`);
+		this._components.set(id, { id, component, ...extra });
+		return id;
+	}
+	text(text, { id, variant = "body" } = {}) {
+		return this.#reg(id, "Text", { text, variant });
+	}
+	image(url, { id, variant, fit = "cover" } = {}) {
+		return this.#reg(id, "Image", { url, ...(variant ? { variant } : {}), fit });
+	}
+	video(url, { id } = {}) {
+		return this.#reg(id, "Video", { url });
+	}
+	checkbox(label, { id, value = false } = {}) {
+		return this.#reg(id, "CheckBox", { label, value });
+	}
+	textField(label, { id, variant = "text" } = {}) {
+		return this.#reg(id, "TextField", { label, variant });
+	}
+	button(childId, { id, variant = "primary", action } = {}) {
+		if (!childId) throw new TypeError("button(childId) requires the id of a child component (e.g. from .text())");
+		return this.#reg(id, "Button", { child: childId, variant, ...(action ? { action } : {}) });
+	}
+	card(childId, { id } = {}) {
+		return this.#reg(id, "Card", { child: childId });
+	}
+	// trigger: id of the component that opens the modal (e.g. a Button); content: id of the
+	// component shown inside it. Both are ids of already-registered SIBLING components, not
+	// nested children — that's how the wire format expects Modal to reference them.
+	modal(triggerId, contentId, { id } = {}) {
+		if (!triggerId) throw new TypeError("modal(triggerId, contentId) requires the id of the trigger component");
+		if (!contentId) throw new TypeError("modal(triggerId, contentId) requires the id of the content component");
+		return this.#reg(id, "Modal", { trigger: triggerId, content: contentId });
+	}
+	// Escape hatch for any catalog component without a dedicated method yet (Divider, Slider,
+	// Switch, List, etc). props is merged as-is into the registered node.
+	raw(component, props = {}, { id } = {}) {
+		if (typeof component !== "string" || !component) throw new TypeError("raw(component, props) requires a non-empty component type string");
+		return this.#reg(id, component, props);
+	}
+	column(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("column(children) requires at least one child id");
+		return this.#reg(id, "Column", { children });
+	}
+	row(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("row(children) requires at least one child id");
+		return this.#reg(id, "Row", { children });
+	}
+	divider({ id } = {}) {
+		return this.#reg(id, "Divider", {});
+	}
+	// JAP@Add --- second-wave catalog components (all register via #reg, so
+	// build()-time ref validation + root()/build()/send() keep working unchanged)
+	slider({ id, value = 0, min = 0, max = 100, step = 1, label } = {}) {
+		return this.#reg(id, "Slider", { value, min, max, step, ...(label !== undefined ? { label } : {}) });
+	}
+	switch(label, { id, value = false } = {}) {
+		return this.#reg(id, "Switch", { label, value });
+	}
+	list(children = [], { id } = {}) {
+		if (!children.length) throw new TypeError("list(children) requires at least one child id");
+		return this.#reg(id, "List", { children });
+	}
+	progressBar(value, { id, min = 0, max = 100, variant = "linear" } = {}) {
+		if (typeof value !== "number") throw new TypeError("progressBar(value) requires a number");
+		return this.#reg(id, "ProgressBar", { value, min, max, variant });
+	}
+	avatar(url, { id, variant = "circle", size = 40 } = {}) {
+		if (!url) throw new TypeError("avatar(url) requires an image url");
+		return this.#reg(id, "Avatar", { url, variant, size });
+	}
+	badge(childId, { id, label } = {}) {
+		if (!childId) throw new TypeError("badge(childId) requires the id of a child component");
+		return this.#reg(id, "Badge", { child: childId, ...(label !== undefined ? { label } : {}) });
+	}
+	spacer({ id, height = 16 } = {}) {
+		return this.#reg(id, "Spacer", { height });
+	}
+	tabs(children = [], { id, activeTab = 0 } = {}) {
+		if (!children.length) throw new TypeError("tabs(children) requires at least one child id");
+		return this.#reg(id, "Tabs", { children, activeTab });
+	}
+	choicePicker(label, options, { id, variant = "mutuallyExclusive", value, displayStyle = "checkbox", filterable = false } = {}) {
+		if (!Array.isArray(options) || !options.length) {
+			throw new TypeError("choicePicker(label, options) requires a non-empty options array of {label, value}");
+		}
+		return this.#reg(id, "ChoicePicker", {
+			label,
+			variant,
+			...(value !== undefined ? { value } : {}),
+			options,
+			displayStyle,
+			filterable
+		});
+	}
+	root(children) {
+		if (!Array.isArray(children) || !children.length) {
+			throw new TypeError("root(children) requires a non-empty array of top-level component ids");
+		}
+		this._rootChildren = children;
+		return this;
+	}
+	// JAP@Add 29-08-26 --- Product/list carousel card. This is a DIFFERENT wire
+	// payload shape from the Column/Row component-tree the rest of this class
+	// builds (type: 'list_card', flat items array) — not a catalog component, so
+	// it doesn't go through #reg()/root(). Call this instead of root()+build();
+	// build() returns the list_card payload directly when this was set.
+	listCard({ title, items, fallbackText, uuid = crypto.randomUUID() } = {}) {
+		if (!title) throw new TypeError("listCard requires a title");
+		if (!Array.isArray(items) || !items.length) {
+			throw new TypeError("listCard requires a non-empty items array");
+		}
+		this._listCardPayload = {
+			uuid,
+			data: JSON.stringify({
+				type: "list_card",
+				title,
+				fallback_text: fallbackText ?? "",
+				items: items.map((it) => ({
+					asset_id: it.assetId ?? crypto.randomUUID().replace(/-/g, "").slice(0, 17),
+					asset_type: it.assetType ?? "PRODUCT_ITEM",
+					title: it.title,
+					trailing_label: it.price ?? it.trailingLabel ?? "",
+					trailing_emphasis: it.emphasis ?? "strong"
+				}))
+			}),
+			type: "im_a2ui",
+			fallback: fallbackText ?? ""
+		};
+		return this;
+	}
+	// JAP@Add 30-08-26 --- send(): terminal method so A2UI can be used as a one-liner like
+	// the other builders (Button/ButtonV2/AIRich `.send()`), instead of always needing the
+	// separate `sendA2UIWidget()` call. Thin wrapper only — root([...ids])/listCard() must
+	// still be called first, same as before build(); this doesn't change the id-returning
+	// factory API (child methods still return ids, not `this`, since sibling nodes need to
+	// reference each other by id when wiring children/trigger/content).
+	async send(client, jid, opts = {}) {
+		return sendA2UIWidget(client, jid, { ...opts, a2ui: this });
+	}
+	// JAP@Add 30-08-26 --- validates that every structural id-reference (child/children on
+	// Button/Card/Column/Row, trigger/content on Modal) points at a component that was
+	// actually registered. Without this, a typo'd id just gets written into the wire payload
+	// as-is and the failure only surfaces as a broken/blank widget on the WA client, with no
+	// error on this end. Only covers the dedicated methods' known reference keys — raw()'s
+	// free-form props aren't inspected, since there's no way to know which of those are id
+	// references vs plain data.
+	#validateRefs(components) {
+		const validIds = new Set(components.map((c) => c.id));
+		for (const c of components) {
+			for (const key of ["child", "trigger", "content"]) {
+				if (c[key] !== undefined && !validIds.has(c[key])) {
+					throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${c[key]}" via "${key}"`);
+				}
+			}
+			if (Array.isArray(c.children)) {
+				for (const childId of c.children) {
+					if (!validIds.has(childId)) {
+						throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${childId}" in "children"`);
+					}
+				}
+			}
+		}
+	}
+	build({ uuid = crypto.randomUUID(), surfaceId, type = "im_a2ui", wrapped = true } = {}) {
+		if (this._listCardPayload) return this._listCardPayload;
+		if (!this._rootChildren.length) throw new Error("Call root([...ids]) before build()");
+		const root = { id: "root", component: "Column", children: this._rootChildren };
+		const components = [root, ...this._components.values()];
+		this.#validateRefs(components);
+		const data = wrapped
+			? {
+					version: this._version,
+					createSurface: {
+						surfaceId: surfaceId ?? `starcore-widget=${uuid}`,
+						catalogId: this._catalogId,
+						components
+					}
+				}
+			: { components };
+		return {
+			uuid,
+			data: JSON.stringify(data),
+			type
+		};
+	}
+}
+
+/**
+ * Build + send an A2UI/Bloks widget as an interactiveMessage.
+ * @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket.
+ * @param {string} jid Destination chat/group jid.
+ */
+async function sendA2UIWidget(client, jid, {
+	a2ui,
+	bodyText = "",
+	footer = "",
+	buttons = [],
+	contextInfo = {},
+	expiration,
+	quoted,
+	type = "im_a2ui",
+	wrapped = true,
+	singleScreen = false,
+	// JAP@Add 30-08-26 --- optional header media, mirroring Button/ButtonV2's toCard()
+	// pattern (prepareWAMessageMedia + client.waUploadToServer). { title, subtitle, image
+	// | video | document: path/buffer/{url} } — media is mutually exclusive, image wins if
+	// more than one is passed. Falls back to a title/subtitle-only header (no attachment)
+	// when no media is given, same shape as before this change.
+	header
+} = {}) {
+	if (!client) throw new Error("Socket is required");
+	if (!(a2ui instanceof A2UI)) throw new TypeError("a2ui must be an A2UI instance");
+
+	const nativeFlowMessage = buttons && buttons.length
+		? {
+				buttons: buttons.map((b) => ({
+					name: b.name ?? "cta_url",
+					buttonParamsJson: typeof b.params === "string" ? b.params : JSON.stringify(b.params ?? {}),
+				})),
+				messageParamsJson: "{}",
+				messageVersion: 1
+			}
+		: { messageParamsJson: "" };
+
+	const headerMediaData = header?.image
+		? { image: header.image }
+		: header?.video
+			? { video: header.video }
+			: header?.document
+				? { document: header.document }
+				: null;
+
+	const headerBlock = {
+		...(header?.title !== undefined ? { title: header.title } : {}),
+		...(header?.subtitle !== undefined ? { subtitle: header.subtitle } : {}),
+		hasMediaAttachment: !!headerMediaData,
+		...(headerMediaData
+			? await prepareWAMessageMedia(headerMediaData, { upload: client.waUploadToServer }).catch((e) => {
+					if (String(e).includes("Invalid media type")) return headerMediaData;
+					throw e;
+				})
+			: {})
+	};
+
+	const interactiveMessage = singleScreen
+		? {
+				nativeFlowMessage,
+				bloksWidget: a2ui.build({ type, wrapped }),
+				...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
+			}
+		: {
+				header: headerBlock,
+				body: { text: bodyText },
+				...(footer ? { footer: { text: footer } } : {}),
+				nativeFlowMessage,
+				bloksWidget: a2ui.build({ type, wrapped }),
+				...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
+			};
+
+	const msg = generateWAMessageFromContent(jid, {
+		messageContextInfo: { messageSecret: crypto.randomBytes(32) },
+		interactiveMessage
+	}, { quoted });
+
+	await client.relayMessage(msg.key.remoteJid, msg.message, {
+		messageId: msg.key.id,
+		additionalNodes: [getBizBinaryNode(msg.message)]
+	});
+	return msg;
+}
+
+export { A2UI, sendA2UIWidget };

package/lib/Builders/AIRich.d.ts

@@ -0,0 +1,105 @@
+import type { BaseBuilder } from './shared.js';
+
+export interface AddTextOptions {
+    hyperlink?: boolean;
+    citation?: boolean;
+    latex?: boolean;
+}
+
+export interface AddInlineImageOptions {
+    text?: string;
+    alignment?: string;
+    tapLinkUrl?: string;
+    resolveUrl?: boolean;
+}
+
+export interface AIRichBuildOptions {
+    forwarded?: boolean;
+    notification?: boolean;
+    includesUnifiedResponse?: boolean;
+    includesSubmessages?: boolean;
+    quoted?: any;
+    quotedParticipant?: string;
+    [key: string]: any;
+}
+
+export interface AIRichSendOptions extends AIRichBuildOptions {
+    skipImageFallback?: boolean;
+    messageId?: string;
+}
+
+export interface AIRichEditOptions {
+    msg?: any;
+    messageId?: string;
+    additionalNodes?: any[];
+    [key: string]: any;
+}
+
+/** AI rich-response builder (Meta AI / GenAI message primitives). */
+export class AIRich extends BaseBuilder {
+    constructor(client: any);
+    addSubmessage(submessage: Record<string, any>): this;
+    addSection(section: Record<string, any>): this;
+    addText(text: string, options?: AddTextOptions): this;
+    addCode(language: string, code: string): this;
+    addTable(table: string[][], options?: AddTextOptions): this;
+    addLinks(links?: Record<string, any>[]): this;
+    addContentItems(items?: Record<string, any>[]): this;
+    addInlineVideo(): this;
+    addSource(sources?: Record<string, any>[], options?: { resolveUrl?: boolean }): this;
+    addReels(reelsItems?: Record<string, any>[], options?: { resolveUrl?: boolean }): this;
+    addImage(imageUrl: string, options?: { resolveUrl?: boolean; instant?: boolean }): this;
+    addInlineImage(imageUrl: string, options?: AddInlineImageOptions): this;
+    addVideo(videoUrl: string, options?: { autoFill?: boolean; resolveUrl?: boolean }): this;
+    addProduct(data?: Record<string, any>, options?: { resolveUrl?: boolean }): this;
+    addPost(data?: Record<string, any>, options?: { resolveUrl?: boolean }): this;
+    addTip(text: string): this;
+    addMetadata(text: string): this;
+    setResponseId(id: string): this;
+    refreshResponseId(): this;
+    setBotResponseId(id: string): this;
+    refreshBotResponseId(): this;
+    hasId(id: string): boolean;
+    getIds(): string[];
+    peek(id: string): { id: string; sections: any[]; submessages: any[] } | null;
+    delete(id: string): this;
+    /** FOATextPrimitive — large heading text, distinct from addText()'s paragraph text. */
+    addHeading(text: string): this;
+    /** GenAI3PExtWidgetPrimitive — experimental, reverse-engineered; see JSDoc in the .js file for caveats. */
+    addWidget(data: Record<string, any> | Record<string, any>[], options?: { layout?: 'Single' | 'HScroll' | 'ActionRow' | string }): this;
+    /** GenAIFooterActionPrimitive — footer action link chips (e.g. "Join our Group"). */
+    addFooterAction(actions: { text: string; url: string; type?: string } | { text: string; url: string; type?: string }[]): this;
+    /** GenAIDividerPrimitive — plain horizontal line, no content. */
+    addDivider(): this;
+    /** GenAISpacerPrimitive — blank vertical spacing. */
+    addSpacer(spacing?: number): this;
+    /** GenAILatexUXPrimitive — has a real AI_RICH_RESPONSE_LATEX submessage (unlike most primitives here). */
+    addLatex(expression: string): this;
+    /** GenAITaskPrimitive — task/checklist card. */
+    addTask(data: { task_id?: string; title: string; subtitle?: string; status?: string; textFallback?: boolean }): this;
+    /** GenAIBotProgressStatusPrimitive — one-shot "searching/working" status chip. */
+    addProgressStatus(title: string, options?: { icon?: string; is_in_progress?: boolean; target_secondary_screen_id?: string; target_secondary_screen_tab_id?: string }): this;
+    /** GenAIBotThinkingStatusPrimitive — one-shot "thinking" status chip. */
+    addThinkingStatus(title: string, options?: { icon?: string; is_in_progress?: boolean; target_secondary_screen_id?: string; target_secondary_screen_tab_id?: string; textFallback?: boolean }): this;
+    /** GenAIMetaSubsQuotaUpsellPrimitive — subscription-quota-limit upsell card. */
+    addQuotaUpsell(data: { title: string; body?: string; body_line1?: string; body_line2?: string; buttons?: { label: string; action?: string; deeplink?: string }[] }): this;
+    /** FOABloksPrimitive — raw Bloks payload; most experimental primitive, fields passed through as-is. */
+    addBloks(data: { type: string; data?: string; uuid?: string; initial_response?: any; versioning_id?: string; textFallback?: boolean }): this;
+    addSuggest(suggestion: Record<string, any>, options?: { scroll?: boolean; layout?: string }): this;
+    /** GenAIImaginePrimitive with status GENERATING — pending-generation placeholder, distinct from addImage()/addVideo()'s READY status. */
+    addGenerating(options?: { imagine_type?: 'IMAGE' | 'ANIMATE'; estimated_completion_time?: number; textFallback?: boolean }): this;
+    build(options?: AIRichBuildOptions): Promise<Record<string, any>>;
+    send(jid: string, options?: AIRichSendOptions): Promise<any>;
+    buildEdit(targetJid: string, targetId: string, options?: AIRichEditOptions): Promise<any>;
+    sendEdit(jid: string, id: string, options?: AIRichEditOptions): Promise<any>;
+    static tokenizer(code: string, lang?: string): Record<string, any>;
+    static toTableMetadata(arr: string[][], options?: AddTextOptions): Record<string, any>;
+    static newLayout(name: string, data: Record<string, any> | Record<string, any>[], extra?: Record<string, any>): Record<string, any>;
+    /** Send a support-ticket marker message (messageContextInfo.supportPayload). */
+    static sendSupportPayload(client: any, jid: string, text: string, options?: { ticketId?: string; isAiMessage?: boolean; shouldShowSystemMessage?: boolean; version?: number }): Promise<any>;
+    /** Send an image + video as one paired-media unit (messageAssociation). */
+    static sendPairedMedia(client: any, jid: string, media: { image: string | Buffer; video: string | Buffer }): Promise<any>;
+}
+
+/** `class ORich extends AIRich {}` — plain re-export alias, no additional members. */
+export class ORich extends AIRich {}