@japofc/baileys 2.1.0

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

@@ -0,0 +1,444 @@
+/**
+ * JAP@Changes 09-04-26 [WIP]
+ * Adds support for tables and code blocks with richResponseMessage (wrapped inside botForwardedMessage).
+ *
+ * If you use or copy this code, please credit my name or project. AND DO NOT CHANGE THIS NOTE
+ */
+import { getRandomValues, randomUUID } from 'crypto';
+import { DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
+import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
+import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
+import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from './generics.js';
+const NOOP = new Set([]);
+// JAP@Fix (bug 40 / inline image): AIRichResponseInlineImageMetadata.imageUrl is a nested
+// AIRichResponseImageURL message (imagePreviewUrl/imageHighResUrl/sourceUrl), NOT a plain string.
+// Passing a raw string made protobufjs silently encode an empty embedded message (no throw),
+// so the image URL data was dropped on the wire and the image never rendered.
+const toImageUrlObject = (url) => {
+    if (!url)
+        return undefined;
+    if (typeof url === 'object')
+        return { imagePreviewUrl: url.imagePreviewUrl || url.url, imageHighResUrl: url.imageHighResUrl || url.url, sourceUrl: url.sourceUrl || url.url };
+    return { imagePreviewUrl: url, imageHighResUrl: url, sourceUrl: url };
+};
+const IMAGE_ALIGNMENT = { leading: 0, trailing: 1, center: 2 };
+const toImageAlignment = (alignment) => {
+    if (typeof alignment === 'number')
+        return alignment;
+    return IMAGE_ALIGNMENT[String(alignment || 'center').toLowerCase()] ?? IMAGE_ALIGNMENT.center;
+};
+export const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        }
+        else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        }
+        else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3],
+            });
+        }
+        else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4],
+            });
+        }
+        else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        }
+        else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+// JAP@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
+export const toUnified = (submessages, uuid) => ({
+    response_id: uuid || randomUUID(),
+    sections: submessages.map((submessage, index) => {
+        switch (submessage.messageType) {
+            case RichSubMessageType.CODE:
+                const codeMetadata = submessage.codeMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            language: codeMetadata.codeLanguage,
+                            code_blocks: codeMetadata.codeBlocks.map((block) => ({ content: block.codeContent, type: CodeHighlightType[block.highlightType] })),
+                            __typename: 'GenAICodeUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.CONTENT_ITEMS:
+                // JAP@Fix (bug 40): was returning {} — now renders content items carousel
+                const contentItemsMeta = submessage.contentItemsMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            items: contentItemsMeta?.itemsMetadata || [],
+                            content_type: contentItemsMeta?.contentType ?? 1,
+                            __typename: 'GenAIContentItemsUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.INLINE_IMAGE:
+                // JAP@Fix (bug 40, round 2): imageUrl is now a real AIRichResponseImageURL
+                // object (imagePreviewUrl/imageHighResUrl/sourceUrl) instead of a bare string
+                // that protobufjs silently dropped on encode. alignment is mapped back to its
+                // enum name (matches how the compiled proto's toObject() renders other enums).
+                const imgMeta = submessage.imageMetadata;
+                const ALIGNMENT_NAME = ['AI_RICH_RESPONSE_IMAGE_LAYOUT_LEADING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_TRAILING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_CENTER_ALIGNED'];
+                return {
+                    view_model: {
+                        primitive: {
+                            image_url: {
+                                image_preview_url: imgMeta?.imageUrl?.imagePreviewUrl || '',
+                                image_high_res_url: imgMeta?.imageUrl?.imageHighResUrl || '',
+                                source_url: imgMeta?.imageUrl?.sourceUrl || ''
+                            },
+                            image_text: imgMeta?.imageText || '',
+                            alignment: ALIGNMENT_NAME[imgMeta?.alignment ?? 2],
+                            tap_link_url: imgMeta?.tapLinkUrl || '',
+                            __typename: 'GenAIInlineImageUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.LATEX:
+                // JAP@Fix (bug 40): was returning {} — now renders LaTeX expressions
+                const latexMeta = submessage.latexMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            text: latexMeta?.text || '',
+                            expressions: latexMeta?.expressions || [],
+                            __typename: 'GenAILatexUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.TABLE:
+                const tableMetadata = submessage.tableMetadata || {};
+                // Accept both the internal row shape ({ items, isHeading }) and
+                // the raw string[][] shape used by some rich-response callers.
+                const rawRows = Array.isArray(tableMetadata.rows) ? tableMetadata.rows : [];
+                const normalizedRows = rawRows.map((row, index) => {
+                    if (Array.isArray(row)) {
+                        return { is_header: index === 0, cells: row.map(String) };
+                    }
+                    const cells = Array.isArray(row?.items) ? row.items.map(String) : [];
+                    return { is_header: !!row?.isHeading, cells };
+                });
+                return {
+                    view_model: {
+                        primitive: {
+                            title: tableMetadata.title || '',
+                            rows: normalizedRows.map((row) => ({
+                                is_header: row.is_header,
+                                cells: row.cells,
+                                markdown_cells: row.cells.map((item) => ({ text: item }))
+                            })),
+                            __typename: 'GenATableUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.TEXT:
+                return {
+                    view_model: {
+                        primitive: {
+                            text: submessage.messageText,
+                            inline_entities: submessage.inlineEntities || [],
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+        }
+        return submessage;
+    })
+});
+export const prepareRichResponseMessage = (content) => {
+    const { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
+    let submessages = [];
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
+                };
+            }
+            else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                };
+            }
+            else if (submessage.items) {
+                return {
+                    messageType: RichSubMessageType.CONTENT_ITEMS,
+                    contentItemsMetadata: {
+                        itemsMetadata: submessage.items,
+                        contentType: proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                    }
+                };
+            }
+            else if (submessage.inlineImage) {
+                return {
+                    messageType: RichSubMessageType.INLINE_IMAGE,
+                    imageMetadata: {
+                        imageUrl: toImageUrlObject(submessage.inlineImage),
+                        imageText: submessage.imageText,
+                        alignment: toImageAlignment(submessage.alignment),
+                        tapLinkUrl: submessage.tapLinkUrl
+                    }
+                };
+            }
+            else if (submessage.inlineVideo) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'INLINE_VIDEO'
+                };
+            }
+            else if (submessage.latex) {
+                return {
+                    messageType: RichSubMessageType.LATEX,
+                    latexMetadata: {
+                        text: submessage.text,
+                        expressions: submessage.latex
+                    }
+                };
+            }
+            else if (submessage.posts) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'POSTS'
+                };
+            }
+            else if (submessage.products) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'PRODUCTS'
+                };
+            }
+            else if (submessage.suggested) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: 'SUGGESTED_PROMPT'
+                };
+            }
+            else if (submessage.table) {
+                const rows = Array.isArray(submessage.table)
+                    ? submessage.table.map((row, index) => Array.isArray(row)
+                        ? { isHeading: index === 0, items: row.map(String) }
+                        : row)
+                    : [];
+                return {
+                    messageType: RichSubMessageType.TABLE,
+                    tableMetadata: {
+                        title: submessage.title || '',
+                        rows
+                    }
+                };
+            }
+            return submessage;
+        });
+    }
+    else {
+        if (headerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: headerText
+            });
+        }
+        if (contentText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: contentText
+            });
+        }
+        if (code) {
+            language ||= 'javascript';
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: tokenizeCode(code, language)
+                }
+            });
+        }
+        if (items) {
+            submessages.push({
+                messageType: RichSubMessageType.CONTENT_ITEMS,
+                contentItemsMetadata: {
+                    itemsMetadata: items,
+                    contentType: proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                }
+            });
+        }
+        if (inlineImage) {
+            submessages.push({
+                messageType: RichSubMessageType.INLINE_IMAGE,
+                imageMetadata: {
+                    imageUrl: toImageUrlObject(inlineImage),
+                    imageText,
+                    alignment: toImageAlignment(alignment),
+                    tapLinkUrl
+                }
+            });
+        }
+        if (inlineVideo) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'INLINE_VIDEO'
+            });
+        }
+        if (latex) {
+            submessages.push({
+                messageType: RichSubMessageType.LATEX,
+                latexMetadata: {
+                    text,
+                    expressions: latex
+                }
+            });
+        }
+        if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                const url = linkField.url || DONATE_URL;
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || 'Donate',
+                    source_subtitle: sourceField.subtitle || 'Saweria',
+                    source_url: sourceField.url || url
+                }));
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [{
+                            key: prefix,
+                            metadata: {
+                                reference_id: index + 1,
+                                reference_url: url,
+                                reference_title: linkField.title || 'For Donation via Saweria',
+                                reference_display_name: linkField.displayName || 'Donation',
+                                sources: sources || [],
+                                __typename: 'GenAISearchCitationItem'
+                            }
+                        }]
+                });
+            });
+        }
+        if (posts) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'POSTS'
+            });
+        }
+        if (products) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'PRODUCTS'
+            });
+        }
+        if (suggested) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: 'SUGGESTED_PROMPT'
+            });
+        }
+        if (table) {
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((items, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items
+                    }))
+                }
+            });
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: footerText
+            });
+        }
+    }
+    const uuid = randomUUID();
+    const unified = toUnified(submessages, uuid);
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: Buffer.from(JSON.stringify(unified)) // JAP@Note 25-04-26 --- Expects "ArrayBufferLike"
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    const message = wrapToBotForwardedMessage(richResponseMessage);
+    const botMetadata = message.messageContextInfo.botMetadata;
+    // JAP@Note 13-05-26 --- Add disclaimer text on richResponseMessage
+    if (disclaimerText) {
+        botMetadata.messageDisclaimerText = disclaimerText;
+    }
+    // JAP@Note 15-05-26 --- Add responseId from unified directly to botMetadata
+    botMetadata.botResponseId = uuid;
+    return message;
+};
+// JAP@Note 17-04-26 --- signature and certificateChain for proofs[] field
+export const botMetadataSignature = () => {
+    const signature = new Uint8Array(64);
+    getRandomValues(signature);
+    return signature;
+};
+export const botMetadataCertificate = (length = 685) => {
+    const certificate = new Uint8Array(length);
+    certificate[0] = 48;
+    certificate[1] = 130;
+    getRandomValues(certificate.subarray(2));
+    return certificate;
+};
+export const wrapToBotForwardedMessage = (richResponseMessage) => ({
+    messageContextInfo: {
+        botMetadata: {
+            // JAP@Note 09-04-26 --- TODO: Fill verificationMetadata field
+            verificationMetadata: {
+                proofs: [
+                    {
+                        certificateChain: [
+                            botMetadataCertificate(),
+                            botMetadataCertificate(892)
+                        ],
+                        version: 1,
+                        useCase: 1,
+                        signature: botMetadataSignature()
+                    }
+                ]
+            }
+        }
+    },
+    botForwardedMessage: {
+        message: { richResponseMessage }
+    }
+});

package/lib/Utils/router.d.ts

@@ -0,0 +1,37 @@
+/**
+ * JAP@Add --- Type declarations for the command router.
+ */
+export declare const extractCommandText: (webMessage: any) => string;
+export interface RouterContext {
+    sock: any;
+    msg: any;
+    key: any;
+    jid: string;
+    sender: string;
+    pushName: string;
+    text: string;
+    raw: string;
+    command: string;
+    args: string[];
+    reply: (content: any, opts?: any) => Promise<any>;
+    react: (emoji: string) => Promise<any>;
+}
+export interface RouterOptions {
+    prefix?: string | string[];
+    ignoreMe?: boolean;
+    help?: boolean;
+    onError?: (err: any, ctx: RouterContext) => void;
+}
+export interface Router {
+    command(names: string | string[], handler: (ctx: RouterContext) => any, opts?: {
+        desc?: string;
+    }): Router;
+    use(mw: (ctx: RouterContext, next: () => Promise<void>) => any): Router;
+    handle(sock: any, webMessage: any): Promise<boolean>;
+    attach(sock: any): () => void;
+    list(): {
+        names: string[];
+        desc: string;
+    }[];
+}
+export declare const createRouter: (opts?: RouterOptions) => Router;

package/lib/Utils/router.js

@@ -0,0 +1,165 @@
+/**
+ * JAP@Add --- Minimal command router for prefix bots.
+ *
+ * ```js
+ * import { createRouter } from '@japofc/baileys'
+ * const router = createRouter({ prefix: '!' })
+ * router.command('ping', async (ctx) => ctx.reply('pong! 🏓'), { desc: 'Check bot' })
+ * router.command(['hi', 'halo'], async (ctx) => ctx.reply(`Halo @${ctx.sender.split('@')[0]}!`))
+ * router.attach(sock) // listens to messages.upsert; returns detach()
+ * ```
+ *
+ * Context: `{ sock, msg, key, jid, sender, pushName, text, raw, command, args,
+ * reply(), react() }`. A `help`/`menu` command is registered automatically
+ * (disable with `{ help: false }`). Handler errors go to `onError`
+ * (default: `console.error`, router keeps running).
+ */
+import { extractMessageContent } from './messages.js';
+/** Pull reply-able text out of any incoming message (text/extended/captions). */
+export const extractCommandText = (webMessage) => {
+    const content = extractMessageContent(webMessage?.message);
+    if (!content) {
+        return '';
+    }
+    return content.conversation
+        || content.extendedTextMessage?.text
+        || content.imageMessage?.caption
+        || content.videoMessage?.caption
+        || '';
+};
+export const createRouter = ({ prefix = '!', ignoreMe = true, help = true, onError } = {}) => {
+    const prefixes = (Array.isArray(prefix) ? prefix : [prefix]).filter((p) => typeof p === 'string' && p);
+    const commands = new Map();
+    const middlewares = [];
+    const handleError = typeof onError === 'function'
+        ? onError
+        : (err, ctx) => console.error(`[router:${ctx?.command || '?'}]`, err);
+    const parse = (text) => {
+        const clean = String(text || '').trim();
+        if (!clean) {
+            return null;
+        }
+        const hit = prefixes.find((p) => clean.startsWith(p));
+        if (!hit) {
+            return null;
+        }
+        const [command, ...args] = clean.slice(hit.length).trim().split(/\s+/).filter(Boolean);
+        if (!command) {
+            return null;
+        }
+        return { command: command.toLowerCase(), args, raw: clean };
+    };
+    const makeCtx = (sock, webMessage, parsed) => {
+        const key = webMessage.key || {};
+        const jid = key.remoteJid;
+        const sender = key.participant || jid;
+        return {
+            sock,
+            msg: webMessage,
+            key,
+            jid,
+            sender,
+            pushName: webMessage.pushName || '',
+            text: parsed.raw,
+            raw: parsed.raw,
+            command: parsed.command,
+            args: parsed.args,
+            reply: (content, opts = {}) => sock.sendMessage(jid, typeof content === 'string' ? { text: content } : content, { quoted: webMessage, ...opts }),
+            react: (emoji) => sock.sendMessage(jid, { react: { text: emoji, key } })
+        };
+    };
+    const runMiddlewares = async (ctx, handler) => {
+        let index = -1;
+        const next = async () => {
+            index++;
+            if (index < middlewares.length) {
+                await middlewares[index](ctx, next);
+            }
+            else {
+                await handler(ctx);
+            }
+        };
+        await next();
+    };
+    const router = {
+        /** Register `command('name' | ['alias', ...], handler, { desc })`. */
+        command(names, handler, { desc = '' } = {}) {
+            const list = (Array.isArray(names) ? names : [names])
+                .map((n) => String(n || '').toLowerCase())
+                .filter(Boolean);
+            if (!list.length || typeof handler !== 'function') {
+                throw new TypeError("router.command(names, handler) requires name(s) + function");
+            }
+            const entry = { handler, desc: String(desc || ''), names: list };
+            for (const name of list) {
+                commands.set(name, entry);
+            }
+            return router;
+        },
+        /** Register middleware `(ctx, next) => { ...; await next() }`. */
+        use(mw) {
+            if (typeof mw !== 'function') {
+                throw new TypeError('router.use(mw) requires a function');
+            }
+            middlewares.push(mw);
+            return router;
+        },
+        /** Handle one incoming message. Returns true when a command matched. */
+        async handle(sock, webMessage) {
+            if (!webMessage?.key || (ignoreMe && webMessage.key.fromMe)) {
+                return false;
+            }
+            const parsed = parse(extractCommandText(webMessage));
+            if (!parsed) {
+                return false;
+            }
+            const entry = commands.get(parsed.command);
+            if (!entry) {
+                return false;
+            }
+            const ctx = makeCtx(sock, webMessage, parsed);
+            try {
+                await runMiddlewares(ctx, entry.handler);
+            }
+            catch (err) {
+                handleError(err, ctx);
+            }
+            return true;
+        },
+        /** Attach to `sock.ev('messages.upsert')`. Returns a detach function. */
+        attach(sock) {
+            const onUpsert = ({ messages } = {}) => {
+                for (const m of messages || []) {
+                    void router.handle(sock, m);
+                }
+            };
+            sock.ev.on('messages.upsert', onUpsert);
+            return () => {
+                try {
+                    sock.ev.off('messages.upsert', onUpsert);
+                }
+                catch { }
+            };
+        },
+        /** List registered primary command names (for custom help screens). */
+        list() {
+            const seen = new Set();
+            const out = [];
+            for (const entry of commands.values()) {
+                if (seen.has(entry)) {
+                    continue;
+                }
+                seen.add(entry);
+                out.push({ names: entry.names, desc: entry.desc });
+            }
+            return out;
+        }
+    };
+    if (help) {
+        router.command(['help', 'menu'], async (ctx) => {
+            const lines = router.list().map(({ names, desc }) => `• ${prefixes[0]}${names[0]}${desc ? ` — ${desc}` : ''}`);
+            await ctx.reply(`🤖 *Bot Menu*\n\n${lines.join('\n') || '(no commands)'}`);
+        }, { desc: 'Show this menu' });
+    }
+    return router;
+};

package/lib/Utils/scheduled-posts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * JAP@Add --- Type declarations for the status/channel schedulers.
+ */
+export interface TimedPostOptions {
+    repeatMs?: number;
+    maxRepeats?: number;
+}
+export interface StatusPostOptions extends TimedPostOptions {
+    jids?: string[];
+}
+declare class BaseTimedPoster {
+    protected sock: any;
+    constructor(sock: any, opts?: {
+        onError?: (err: any, id: string) => void;
+    });
+    cancel(id: string): boolean;
+    clear(): void;
+    pending(): {
+        id: string;
+        runs: number;
+    }[];
+}
+export declare class StatusScheduler extends BaseTimedPoster {
+    schedule(content: any, when: Date | number, opts?: StatusPostOptions): string;
+    scheduleIn(content: any, delayMs: number, opts?: StatusPostOptions): string;
+}
+export declare class ChannelScheduler extends BaseTimedPoster {
+    schedule(channelJid: string, content: any, when: Date | number, opts?: TimedPostOptions): string;
+    scheduleIn(channelJid: string, content: any, delayMs: number, opts?: TimedPostOptions): string;
+}