@awangxcode/qiro-baileys 0.0.0-stage → 7.0.0-rc16

package/lib/MessageBuilder/index.js

@@ -0,0 +1,673 @@
+import { generateMessageID } from '../Utils/generics.js';
+import { proto } from '../../WAProto/index.js';
+const COMMON_NATIVE_FLOW_BUTTONS = new Set([
+    'quick_reply',
+    'cta_url',
+    'cta_call',
+    'cta_copy',
+    'cta_catalog',
+    'catalog_message',
+    'galaxy_message',
+    'order_status',
+    'payment_reminder',
+    'booking_confirmation',
+    'payment_request',
+    'api_signup',
+    'inapp_signup',
+    'cta_app',
+    'form_message'
+]);
+const ANDROID_ONLY_NATIVE_FLOW_BUTTONS = new Set([
+    'single_select',
+    'send_location',
+    'address_message',
+    'cta_reminder',
+    'cta_cancel_reminder'
+]);
+const isQuickReply = (button) => button.name === 'quick_reply';
+/** Runtime guard for values supplied by JavaScript callers or untyped input. */
+const isPlainRecord = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+const hasTextParam = (button, name) => {
+    const value = button.params[name];
+    return typeof value === 'string' && value.trim().length > 0;
+};
+const validateButtonParams = (button, index) => {
+    const errors = [];
+    const requiredByType = {
+        quick_reply: ['display_text', 'id'],
+        cta_url: ['display_text', 'url'],
+        cta_call: ['display_text', 'phone_number'],
+        cta_copy: ['display_text', 'copy_code'],
+        cta_catalog: ['display_text'],
+        catalog_message: ['display_text'],
+        single_select: ['title', 'sections']
+    };
+    for (const key of requiredByType[button.name] ?? []) {
+        if (key === 'sections') {
+            const sections = button.params.sections;
+            if (!Array.isArray(sections) || sections.length === 0) {
+                errors.push(`Button ${index + 1} (${button.name}) must include a non-empty sections array`);
+            }
+            else {
+                sections.forEach((section, sectionIndex) => {
+                    if (!isPlainRecord(section)) {
+                        errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' must be an object');
+                        return;
+                    }
+                    if (typeof section.title !== 'string' || !section.title.trim()) {
+                        errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' needs a title');
+                    }
+                    const rows = section.rows;
+                    if (!Array.isArray(rows) || rows.length === 0) {
+                        errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' must contain at least one row');
+                        return;
+                    }
+                    rows.forEach((row, rowIndex) => {
+                        if (!isPlainRecord(row)) {
+                            errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' row ' + (rowIndex + 1) + ' must be an object');
+                            return;
+                        }
+                        if (typeof row.title !== 'string' || !row.title.trim()) {
+                            errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' row ' + (rowIndex + 1) + ' needs a title');
+                        }
+                        if (typeof row.id !== 'string' || !row.id.trim()) {
+                            errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' row ' + (rowIndex + 1) + ' needs an id');
+                        }
+                        for (const field of ['header', 'description']) {
+                            if (row[field] !== undefined && typeof row[field] !== 'string') {
+                                errors.push('Button ' + (index + 1) + ' section ' + (sectionIndex + 1) + ' row ' + (rowIndex + 1) + ' ' + field + ' must be a string');
+                            }
+                        }
+                    });
+                });
+            }
+        }
+        else if (!hasTextParam(button, key)) {
+            errors.push(`Button ${index + 1} (${button.name}) requires a non-empty ${key}`);
+        }
+    }
+    if (button.name === 'cta_url' && hasTextParam(button, 'url')) {
+        try {
+            const url = new URL(button.params.url);
+            if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+                errors.push(`Button ${index + 1} has an unsafe URL; use http(s) without embedded credentials`);
+            }
+        }
+        catch {
+            errors.push(`Button ${index + 1} has an invalid URL`);
+        }
+    }
+    if (button.name === 'cta_call' && hasTextParam(button, 'phone_number')) {
+        if (!/^\+?[1-9]\d{6,14}$/.test(button.params.phone_number)) {
+            errors.push(`Button ${index + 1} phone_number must be an international number with 7–15 digits`);
+        }
+    }
+    return errors;
+};
+/**
+ * Validate native-flow button combinations against the currently documented WA Web/iOS
+ * constraints. This is a client-compatibility check, not a guarantee that WhatsApp will
+ * render a server-side or account-gated feature.
+ */
+export const checkNativeFlowButtons = (buttons, platform = 'web', options = {}) => {
+    const errors = [];
+    if (!Array.isArray(buttons)) {
+        return { ok: false, platform, maxButtons: 0, errors: ['buttons must be an array'] };
+    }
+    if (!['web', 'ios', 'android'].includes(platform)) {
+        errors.push('platform must be one of: web, ios, android');
+    }
+    const first = buttons[0];
+    const firstIsQuickReply = isPlainRecord(first) && first.name === 'quick_reply';
+    const maxButtons = firstIsQuickReply ? 10 : 3;
+    const allowExperimental = isPlainRecord(options) && options.allowExperimentalNativeFlowTypes === true;
+    if (!buttons.length)
+        errors.push('At least one native-flow button is required');
+    if (buttons.length > maxButtons) {
+        errors.push((firstIsQuickReply ? 'quick_reply' : 'non-quick-reply') + ' messages support at most ' + maxButtons + ' buttons');
+    }
+    for (const [index, input] of buttons.entries()) {
+        if (!isPlainRecord(input)) {
+            errors.push('Button ' + (index + 1) + ' must be an object');
+            continue;
+        }
+        const name = input.name;
+        if (typeof name !== 'string' || !name.trim()) {
+            errors.push('Button ' + (index + 1) + ' has an empty or invalid name');
+            continue;
+        }
+        const params = input.params;
+        if (!isPlainRecord(params)) {
+            errors.push('Button ' + (index + 1) + ' (' + name + ') params must be a plain object');
+            continue;
+        }
+        const button = { name, params };
+        const known = COMMON_NATIVE_FLOW_BUTTONS.has(button.name) || ANDROID_ONLY_NATIVE_FLOW_BUTTONS.has(button.name);
+        if (!known && !allowExperimental) {
+            errors.push('Button ' + (index + 1) + ' uses an unknown native-flow type: ' + button.name);
+            continue;
+        }
+        if (known)
+            errors.push(...validateButtonParams(button, index));
+        if (platform !== 'android' && ANDROID_ONLY_NATIVE_FLOW_BUTTONS.has(button.name)) {
+            errors.push(button.name + ' is documented as Android-only and is not portable to ' + platform);
+        }
+        if (index > 0 && firstIsQuickReply !== isQuickReply(button)) {
+            errors.push('quick_reply buttons cannot be mixed with other native-flow button types');
+        }
+    }
+    return { ok: errors.length === 0, platform, maxButtons, errors };
+};
+export const isWebSupportedNativeFlowButton = (name) => COMMON_NATIVE_FLOW_BUTTONS.has(name);
+const createNativeFlowMetadataNode = () => ({
+    tag: 'biz',
+    attrs: {
+        actual_actors: '2',
+        host_storage: '2',
+        privacy_mode_ts: String(Date.now())
+    },
+    content: [
+        {
+            tag: 'interactive',
+            attrs: { type: 'native_flow', v: '1' },
+            content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+        }
+    ]
+});
+const ensureText = (value, field) => {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new TypeError(field + ' must be a non-empty string');
+    }
+};
+const serializeButton = (button) => {
+    let buttonParamsJson;
+    try {
+        buttonParamsJson = JSON.stringify(button.params);
+    }
+    catch {
+        throw new TypeError('Button ' + button.name + ' params must be JSON-serializable');
+    }
+    if (typeof buttonParamsJson !== 'string') {
+        throw new TypeError('Button ' + button.name + ' params must be JSON-serializable');
+    }
+    return { name: button.name, buttonParamsJson };
+};
+/**
+ * Native-flow button builder integrated into Qiro Baileys. It intentionally builds only
+ * protocol payloads that are represented by the bundled WAProto types; it does not try
+ * to bypass device or server-side feature gates.
+ */
+export class Button {
+    constructor(socket) {
+        this.titleText = '';
+        this.subtitleText = '';
+        this.body = '';
+        this.footerText = '';
+        this.buttons = [];
+        this.socket = socket;
+    }
+    setTitle(value) {
+        this.titleText = value;
+        return this;
+    }
+    title(value) {
+        return this.setTitle(value);
+    }
+    /** Fluent alias compatible with common MessageBuilder APIs. */
+    header(value) {
+        return this.setTitle(value);
+    }
+    setSubtitle(value) {
+        this.subtitleText = value;
+        return this;
+    }
+    subtitle(value) {
+        return this.setSubtitle(value);
+    }
+    setBody(value) {
+        this.body = value;
+        return this;
+    }
+    /** Fluent alias compatible with common MessageBuilder APIs. */
+    text(value) {
+        return this.setBody(value);
+    }
+    setFooter(value) {
+        this.footerText = value;
+        return this;
+    }
+    footer(value) {
+        return this.setFooter(value);
+    }
+    /** Set an already-prepared protobuf header; media upload is intentionally not hidden here. */
+    setHeader(value) {
+        this.headerPayload = structuredClone(value);
+        return this;
+    }
+    addReply(displayText, id) {
+        ensureText(displayText, 'displayText');
+        ensureText(id, 'id');
+        this.buttons.push({ name: 'quick_reply', params: { display_text: displayText, id } });
+        return this;
+    }
+    /** Fluent alias for addReply(). */
+    button(displayText, id) {
+        return this.addReply(displayText, id);
+    }
+    addUrl(displayText, url) {
+        ensureText(displayText, 'displayText');
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new TypeError('Button URL must be an absolute URL using http or https');
+        }
+        if ((parsed.protocol !== 'https:' && parsed.protocol !== 'http:') ||
+            parsed.username.length > 0 ||
+            parsed.password.length > 0) {
+            throw new TypeError('Button URL must use http or https and must not include embedded credentials');
+        }
+        const safeUrl = parsed.toString();
+        this.buttons.push({
+            name: 'cta_url',
+            params: { display_text: displayText, url: safeUrl, merchant_url: safeUrl }
+        });
+        return this;
+    }
+    addCopy(displayText, copyCode) {
+        ensureText(displayText, 'displayText');
+        ensureText(copyCode, 'copyCode');
+        this.buttons.push({ name: 'cta_copy', params: { display_text: displayText, copy_code: copyCode } });
+        return this;
+    }
+    addCall(displayText, phoneNumber) {
+        ensureText(displayText, 'displayText');
+        if (!/^\+?[1-9]\d{6,14}$/.test(phoneNumber)) {
+            throw new TypeError('phoneNumber must be an international number with 7–15 digits');
+        }
+        this.buttons.push({ name: 'cta_call', params: { display_text: displayText, phone_number: phoneNumber } });
+        return this;
+    }
+    /** Escape hatch for documented native-flow types not covered by a convenience method. */
+    addNativeButton(name, params) {
+        ensureText(name, 'name');
+        if (!isPlainRecord(params)) {
+            throw new TypeError('params must be a plain object');
+        }
+        this.buttons.push({ name, params: structuredClone(params) });
+        return this;
+    }
+    addSelection(title) {
+        ensureText(title, 'title');
+        this.selection = { title, sections: [] };
+        this.currentSection = undefined;
+        return this;
+    }
+    makeSection(title) {
+        ensureText(title, 'title');
+        if (!this.selection)
+            throw new Error('Call addSelection(title) before makeSection(title)');
+        const section = { title, rows: [] };
+        this.selection.sections.push(section);
+        this.currentSection = section;
+        return this;
+    }
+    makeRow(header, title, description, id) {
+        if (!this.selection || !this.currentSection)
+            throw new Error('Call addSelection() and makeSection() before makeRow()');
+        ensureText(title, 'title');
+        ensureText(id, 'id');
+        this.currentSection.rows.push({ header: header || undefined, title, description: description || undefined, id });
+        return this;
+    }
+    getButtonInputs() {
+        const result = [...this.buttons];
+        if (this.selection) {
+            if (!this.selection.sections.length || this.selection.sections.some(section => !section.rows.length)) {
+                throw new TypeError('single_select needs at least one non-empty section');
+            }
+            result.push({
+                name: 'single_select',
+                params: { title: this.selection.title, sections: this.selection.sections }
+            });
+        }
+        return result;
+    }
+    build(options = {}) {
+        ensureText(this.body, 'body');
+        const buttons = this.getButtonInputs();
+        const validation = checkNativeFlowButtons(buttons, options.platform ?? 'web', {
+            allowExperimentalNativeFlowTypes: options.allowExperimentalNativeFlowTypes
+        });
+        if (!validation.ok)
+            throw new TypeError(`Invalid native-flow buttons: ${validation.errors.join('; ')}`);
+        const header = this.headerPayload ??
+            (this.titleText || this.subtitleText
+                ? { title: this.titleText || undefined, subtitle: this.subtitleText || undefined }
+                : undefined);
+        return {
+            interactiveMessage: {
+                header,
+                body: { text: this.body },
+                footer: this.footerText ? { text: this.footerText } : undefined,
+                nativeFlowMessage: {
+                    messageVersion: 1,
+                    buttons: buttons.map(serializeButton)
+                }
+            }
+        };
+    }
+    toCard(options = {}) {
+        const message = this.build(options).interactiveMessage;
+        if (!message)
+            throw new Error('Failed to construct interactive card');
+        if (!message.header?.imageMessage && !message.header?.videoMessage) {
+            throw new TypeError('Carousel cards require a prepared imageMessage or videoMessage in the header');
+        }
+        return message;
+    }
+    async send(jid, options = {}) {
+        return this.socket.relayMessage(jid, this.build(options), {
+            messageId: options.messageId ?? generateMessageID(),
+            additionalNodes: [createNativeFlowMetadataNode()]
+        });
+    }
+}
+/** ButtonV2 exposes a compact quick-reply API over the same validated native-flow format. */
+export class ButtonV2 extends Button {
+    addButton(displayText, id) {
+        return this.addReply(displayText, id);
+    }
+}
+/**
+ * Carousel builder for already-prepared protobuf cards. Each card must include image or
+ * video media metadata; use the normal media preparation utilities before adding it.
+ */
+export class Carousel {
+    constructor(socket) {
+        this.body = '';
+        this.footerText = '';
+        this.cards = [];
+        this.socket = socket;
+    }
+    setBody(value) {
+        this.body = value;
+        return this;
+    }
+    text(value) {
+        return this.setBody(value);
+    }
+    setFooter(value) {
+        this.footerText = value;
+        return this;
+    }
+    footer(value) {
+        return this.setFooter(value);
+    }
+    addCard(card) {
+        const items = Array.isArray(card) ? card : [card];
+        const preparedCards = [];
+        // Validate the full batch before mutating state, so an invalid later card does not
+        // leave a partially-added carousel behind.
+        for (const item of items) {
+            if (!item || typeof item !== 'object') {
+                throw new TypeError('Every carousel card must be an interactive-message object');
+            }
+            if (!item.header?.imageMessage && !item.header?.videoMessage) {
+                throw new TypeError('Every carousel card must have a prepared imageMessage or videoMessage in its header');
+            }
+            if (typeof item.body?.text !== 'string' || !item.body.text.trim()) {
+                throw new TypeError('Every carousel card must have non-empty body text');
+            }
+            preparedCards.push(structuredClone(item));
+        }
+        this.cards.push(...preparedCards);
+        return this;
+    }
+    build() {
+        ensureText(this.body, 'body');
+        if (this.cards.length < 2)
+            throw new TypeError('Carousel needs at least two cards');
+        return {
+            interactiveMessage: {
+                body: { text: this.body },
+                footer: this.footerText ? { text: this.footerText } : undefined,
+                carouselMessage: {
+                    messageVersion: 1,
+                    carouselCardType: proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType.HSCROLL_CARDS,
+                    cards: this.cards
+                }
+            }
+        };
+    }
+    async send(jid, options = {}) {
+        return this.socket.relayMessage(jid, this.build(), {
+            messageId: options.messageId ?? generateMessageID(),
+            additionalNodes: [createNativeFlowMetadataNode()]
+        });
+    }
+}
+const parseHttpUrl = (value, field) => {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new TypeError(`${field} must be a valid absolute URL`);
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password) {
+        throw new TypeError(`${field} must use http(s) and must not include embedded credentials`);
+    }
+    return parsed;
+};
+/**
+ * Experimental builder for the AIRichResponse protobuf types already bundled in WAProto.
+ * This creates a validly-shaped payload only; WhatsApp may gate or change how these
+ * internal/experimental message types are rendered on different clients.
+ */
+export class AIRich {
+    constructor(socket) {
+        this.submessages = [];
+        this.sources = [];
+        this.socket = socket;
+    }
+    text(value) {
+        return this.addText(value);
+    }
+    addText(value) {
+        ensureText(value, 'text');
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT,
+            messageText: value
+        });
+        return this;
+    }
+    addCode(language, code) {
+        ensureText(language, 'language');
+        ensureText(code, 'code');
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_CODE,
+            codeMetadata: {
+                codeLanguage: language.trim(),
+                codeBlocks: [
+                    {
+                        highlightType: proto.AIRichResponseCodeMetadata.AIRichResponseCodeHighlightType.AI_RICH_RESPONSE_CODE_HIGHLIGHT_DEFAULT,
+                        codeContent: code
+                    }
+                ]
+            }
+        });
+        return this;
+    }
+    addTable(rows, title) {
+        if (!Array.isArray(rows) || rows.length === 0)
+            throw new TypeError('rows must contain at least one row');
+        if (!rows.every(row => Array.isArray(row) && row.length > 0)) {
+            throw new TypeError('each table row must contain at least one cell');
+        }
+        const width = rows[0].length;
+        if (!rows.every(row => row.length === width))
+            throw new TypeError('all table rows must have the same number of cells');
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TABLE,
+            tableMetadata: {
+                title,
+                rows: rows.map((items, index) => ({ items: items.map(String), isHeading: index === 0 }))
+            }
+        });
+        return this;
+    }
+    addLatex(expression, options = {}) {
+        ensureText(expression, 'expression');
+        const renderedImageUrl = options.renderedImageUrl;
+        if (renderedImageUrl)
+            parseHttpUrl(renderedImageUrl, 'renderedImageUrl');
+        for (const [name, value] of Object.entries({ width: options.width, height: options.height })) {
+            if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+                throw new TypeError(`${name} must be a positive finite number`);
+            }
+        }
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_LATEX,
+            latexMetadata: {
+                text: expression,
+                expressions: [
+                    {
+                        latexExpression: expression,
+                        url: renderedImageUrl,
+                        width: options.width,
+                        height: options.height
+                    }
+                ]
+            }
+        });
+        return this;
+    }
+    addInlineImage(url, altText = '', alignment = proto.AIRichResponseInlineImageMetadata.AIRichResponseImageAlignment.AI_RICH_RESPONSE_IMAGE_LAYOUT_CENTER_ALIGNED, tapLinkUrl) {
+        const imageUrl = parseHttpUrl(url, 'url').toString();
+        if (tapLinkUrl)
+            parseHttpUrl(tapLinkUrl, 'tapLinkUrl');
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_INLINE_IMAGE,
+            imageMetadata: {
+                imageUrl: { imagePreviewUrl: imageUrl, imageHighResUrl: imageUrl, sourceUrl: imageUrl },
+                imageText: altText || undefined,
+                alignment,
+                tapLinkUrl
+            }
+        });
+        return this;
+    }
+    addMap(centerLatitude, centerLongitude, annotations) {
+        const validCoordinate = (latitude, longitude) => Number.isFinite(latitude) && Number.isFinite(longitude) && Math.abs(latitude) <= 90 && Math.abs(longitude) <= 180;
+        if (!validCoordinate(centerLatitude, centerLongitude))
+            throw new TypeError('map center coordinates are invalid');
+        if (!Array.isArray(annotations))
+            throw new TypeError('annotations must be an array');
+        annotations.forEach((annotation, index) => {
+            if (!isPlainRecord(annotation)) {
+                throw new TypeError('map annotation ' + (index + 1) + ' must be an object');
+            }
+            if (!validCoordinate(annotation.latitude, annotation.longitude)) {
+                throw new TypeError('map annotation ' + (index + 1) + ' has invalid coordinates');
+            }
+            for (const field of ['title', 'body']) {
+                if (annotation[field] !== undefined && typeof annotation[field] !== 'string') {
+                    throw new TypeError('map annotation ' + (index + 1) + ' ' + field + ' must be a string');
+                }
+            }
+        });
+        this.submessages.push({
+            messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_MAP,
+            mapMetadata: {
+                centerLatitude,
+                centerLongitude,
+                annotations: annotations.map((item, index) => ({
+                    annotationNumber: index + 1,
+                    latitude: item.latitude,
+                    longitude: item.longitude,
+                    title: item.title,
+                    body: item.body
+                }))
+            }
+        });
+        return this;
+    }
+    addSource(source) {
+        ensureText(source.title, 'source.title');
+        const url = parseHttpUrl(source.url, 'source.url').toString();
+        if (source.thumbnailUrl)
+            parseHttpUrl(source.thumbnailUrl, 'source.thumbnailUrl');
+        if (source.faviconUrl)
+            parseHttpUrl(source.faviconUrl, 'source.faviconUrl');
+        this.sources.push({
+            provider: source.provider,
+            sourceTitle: source.title,
+            sourceProviderUrl: url,
+            sourceQuery: source.query,
+            thumbnailCdnUrl: source.thumbnailUrl,
+            faviconCdnUrl: source.faviconUrl,
+            citationNumber: this.sources.length + 1
+        });
+        return this;
+    }
+    /** Add a WAProto submessage directly for advanced, version-aware use cases. */
+    addSubmessage(submessage) {
+        if (!submessage || typeof submessage !== 'object' || submessage.messageType === undefined) {
+            throw new TypeError('submessage must be an object with a messageType');
+        }
+        this.submessages.push(structuredClone(submessage));
+        return this;
+    }
+    build() {
+        if (this.submessages.length === 0)
+            throw new TypeError('AIRich requires at least one submessage');
+        const message = {
+            richResponseMessage: {
+                messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+                submessages: structuredClone(this.submessages)
+            }
+        };
+        if (this.sources.length) {
+            message.messageContextInfo = {
+                botMetadata: {
+                    richResponseSourcesMetadata: { sources: structuredClone(this.sources) }
+                }
+            };
+        }
+        return message;
+    }
+    async send(jid, options = {}) {
+        if (!this.socket)
+            throw new Error('AIRich.send() requires a socket; construct with new AIRich(sock)');
+        return this.socket.relayMessage(jid, this.build(), { messageId: options.messageId ?? generateMessageID() });
+    }
+}
+/** Small, deterministic utilities; unlike remote auto-update helpers, these never fetch or execute code. */
+export const Toolkit = Object.freeze({
+    checkNativeFlowButtons,
+    isWebSupportedNativeFlowButton,
+    validateHttpUrl: (url) => parseHttpUrl(url, 'url').toString(),
+    textMessage: (text) => {
+        ensureText(text, 'text');
+        return { conversation: text };
+    },
+    cloneMessage: (message) => structuredClone(message)
+});
+export const MessageBuilder = {
+    Button,
+    ButtonV2,
+    Carousel,
+    AIRich,
+    Toolkit,
+    checkNativeFlowButtons,
+    isWebSupportedNativeFlowButton
+};
+export const MB = MessageBuilder;
+//# sourceMappingURL=index.js.map