@japofc/baileys 2.1.0

package/lib/Utils/scheduled-posts.js

@@ -0,0 +1,110 @@
+/**
+ * JAP@Add --- Status + channel post schedulers.
+ *
+ * ```js
+ * import { StatusScheduler, ChannelScheduler, StatusHelper } from '@japofc/baileys'
+ * const statusQ = new StatusScheduler(sock)
+ * statusQ.schedule(StatusHelper.text('Selamat pagi! ☀️'), new Date('2026-09-11T06:00:00+07:00'))
+ * statusQ.scheduleIn(StatusHelper.text('Promo!'), 3600_000, { repeatMs: 86400_000 }) // hourly-ish
+ *
+ * const channelQ = new ChannelScheduler(sock)
+ * channelQ.schedule('123@newsletter', { text: 'Update harian' }, runAt)
+ * ```
+ *
+ * In-memory only (jobs vanish on restart — persist `pending()` yourself if needed).
+ */
+import { Boom } from '@hapi/boom';
+import { StatusHelper } from './status.js';
+class BaseTimedPoster {
+    constructor(sock, { onError } = {}) {
+        if (!sock || typeof sock.sendMessage !== 'function') {
+            throw new Boom('Scheduler(sock, ...) requires an active Baileys socket', { statusCode: 400 });
+        }
+        this.sock = sock;
+        this.onError = typeof onError === 'function' ? onError : null;
+        this.jobs = new Map();
+        this.seq = 0;
+    }
+    _schedule(sendFn, when, { repeatMs, maxRepeats } = {}) {
+        const target = when instanceof Date ? when.getTime() : Number(when);
+        if (!Number.isFinite(target)) {
+            throw new Boom('schedule(when) needs a Date or epoch-ms number', { statusCode: 400 });
+        }
+        if (repeatMs !== undefined && (!Number.isFinite(Number(repeatMs)) || Number(repeatMs) <= 0)) {
+            throw new Boom('repeatMs must be a positive number', { statusCode: 400 });
+        }
+        const id = `post_${Date.now()}_${++this.seq}`;
+        const job = { id, timer: null, runs: 0, cancelled: false };
+        const tick = async () => {
+            if (job.cancelled) {
+                return;
+            }
+            job.runs++;
+            try {
+                await sendFn();
+            }
+            catch (err) {
+                try {
+                    this.onError?.(err, id);
+                }
+                catch { }
+            }
+            if (job.cancelled) {
+                return;
+            }
+            if (repeatMs && (maxRepeats == null || job.runs < maxRepeats)) {
+                job.timer = setTimeout(tick, Number(repeatMs));
+                job.timer.unref?.();
+            }
+            else {
+                this.jobs.delete(id);
+            }
+        };
+        job.timer = setTimeout(tick, Math.max(0, target - Date.now()));
+        job.timer.unref?.();
+        this.jobs.set(id, job);
+        return id;
+    }
+    /** Cancel one job. Returns true if it existed. */
+    cancel(id) {
+        const job = this.jobs.get(id);
+        if (!job) {
+            return false;
+        }
+        job.cancelled = true;
+        clearTimeout(job.timer);
+        this.jobs.delete(id);
+        return true;
+    }
+    /** Cancel everything. */
+    clear() {
+        for (const id of [...this.jobs.keys()]) {
+            this.cancel(id);
+        }
+    }
+    /** List pending job ids + run counts. */
+    pending() {
+        return [...this.jobs.values()].map(({ id, runs }) => ({ id, runs }));
+    }
+}
+/** Schedule status posts (broadcast or targeted via `jids`). */
+export class StatusScheduler extends BaseTimedPoster {
+    schedule(content, when, { jids = [], repeatMs, maxRepeats } = {}) {
+        return this._schedule(() => StatusHelper.send(this.sock, content, jids), when, { repeatMs, maxRepeats });
+    }
+    scheduleIn(content, delayMs, opts = {}) {
+        return this.schedule(content, Date.now() + Number(delayMs), opts);
+    }
+}
+/** Schedule channel/newsletter posts. */
+export class ChannelScheduler extends BaseTimedPoster {
+    schedule(channelJid, content, when, { repeatMs, maxRepeats } = {}) {
+        if (typeof channelJid !== 'string' || !channelJid.endsWith('@newsletter')) {
+            throw new Boom('ChannelScheduler.schedule needs a channel JID (@newsletter)', { statusCode: 400 });
+        }
+        return this._schedule(() => this.sock.sendMessage(channelJid, content), when, { repeatMs, maxRepeats });
+    }
+    scheduleIn(channelJid, content, delayMs, opts = {}) {
+        return this.schedule(channelJid, content, Date.now() + Number(delayMs), opts);
+    }
+}

package/lib/Utils/scheduling.d.ts

@@ -0,0 +1,42 @@
+import type { WAMessage, AnyMessageContent } from '../Types/index.js';
+export interface SchedulerOptions {
+    maxQueue?: number;
+    checkInterval?: number;
+    onSent?: (scheduled: ScheduledMessage, message?: WAMessage) => void;
+    onFailed?: (scheduled: ScheduledMessage, error: Error) => void;
+}
+export type ScheduledMessageStatus = 'pending' | 'sent' | 'failed' | 'cancelled';
+export interface RepeatOptions {
+    repeatIntervalMs?: number;
+    maxRepeats?: number;
+}
+export interface ScheduledMessage {
+    id: string;
+    jid: string;
+    content: AnyMessageContent;
+    scheduledTime: Date;
+    createdAt: Date;
+    status: ScheduledMessageStatus;
+    messageId?: string;
+    error?: string;
+    repeatIntervalMs?: number;
+    maxRepeats?: number;
+    repeatCount?: number;
+}
+export declare class MessageScheduler {
+    private queue;
+    private timer;
+    private sendMessage;
+    private options;
+    constructor(sendMessage: (jid: string, content: AnyMessageContent) => Promise<WAMessage | undefined>, options?: SchedulerOptions);
+    schedule(jid: string, content: AnyMessageContent, scheduledTime: Date, repeatOptions?: RepeatOptions): ScheduledMessage;
+    scheduleDelay(jid: string, content: AnyMessageContent, delayMs: number, repeatOptions?: RepeatOptions): ScheduledMessage;
+    cancel(id: string): boolean;
+    cancelForJid(jid: string): number;
+    getPending(): ScheduledMessage[];
+    get(id: string): ScheduledMessage | undefined;
+    clearAll(): number;
+    stop(): void;
+    start(): void;
+}
+export declare const createMessageScheduler: (sendMessage: (jid: string, content: AnyMessageContent) => Promise<WAMessage | undefined>, options?: SchedulerOptions) => MessageScheduler;

package/lib/Utils/scheduling.js

@@ -0,0 +1,139 @@
+/**
+ * JAP@Add --- part of the @japofc/baileys utils (scheduling.ts) + message-scheduler.ts.
+ * These were originally two separate, overlapping schedulers (one class-based
+ * with polling, one function-based with setTimeout + repeat support). Merged here into
+ * a single class-based scheduler so multiple independent instances can be bound to
+ * different sendMessage functions (e.g. multi-session bots), while keeping the
+ * repeat-interval/maxRepeats feature from the function-based version.
+ */
+export class MessageScheduler {
+    queue = new Map();
+    timer = null;
+    sendMessage;
+    options;
+    constructor(sendMessage, options = {}) {
+        this.sendMessage = sendMessage;
+        this.options = {
+            maxQueue: options.maxQueue ?? 1000,
+            checkInterval: options.checkInterval ?? 1000,
+            onSent: options.onSent ?? (() => { }),
+            onFailed: options.onFailed ?? (() => { })
+        };
+    }
+    generateId() {
+        return `sched_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Schedule a message for a specific Date. Pass `repeatIntervalMs` to
+     * re-queue the job that many ms after each send (optionally capped by
+     * `maxRepeats`).
+     */
+    schedule(jid, content, scheduledTime, repeatOptions) {
+        if (this.queue.size >= this.options.maxQueue)
+            throw new Error(`Maximum queue size (${this.options.maxQueue}) reached`);
+        if (scheduledTime.getTime() <= Date.now())
+            throw new Error('Scheduled time must be in the future');
+        const scheduled = {
+            id: this.generateId(),
+            jid,
+            content,
+            scheduledTime,
+            createdAt: new Date(),
+            status: 'pending',
+            repeatIntervalMs: repeatOptions?.repeatIntervalMs,
+            maxRepeats: repeatOptions?.maxRepeats,
+            repeatCount: 0
+        };
+        this.queue.set(scheduled.id, scheduled);
+        this.ensureTimerRunning();
+        return scheduled;
+    }
+    scheduleDelay(jid, content, delayMs, repeatOptions) {
+        return this.schedule(jid, content, new Date(Date.now() + delayMs), repeatOptions);
+    }
+    cancel(id) {
+        const s = this.queue.get(id);
+        if (s?.status === 'pending') {
+            s.status = 'cancelled';
+            this.queue.delete(id);
+            return true;
+        }
+        return false;
+    }
+    cancelForJid(jid) {
+        let cancelled = 0;
+        for (const [id, s] of this.queue) {
+            if (s.jid === jid && s.status === 'pending') {
+                s.status = 'cancelled';
+                this.queue.delete(id);
+                cancelled++;
+            }
+        }
+        return cancelled;
+    }
+    getPending() {
+        return Array.from(this.queue.values()).filter((s) => s.status === 'pending');
+    }
+    get(id) {
+        return this.queue.get(id);
+    }
+    clearAll() {
+        const count = this.queue.size;
+        this.queue.clear();
+        this.stopTimer();
+        return count;
+    }
+    async processQueue() {
+        const now = Date.now();
+        for (const [id, s] of this.queue) {
+            if (s.status !== 'pending')
+                continue;
+            if (s.scheduledTime.getTime() > now)
+                continue;
+            try {
+                const message = await this.sendMessage(s.jid, s.content);
+                s.messageId = message?.key?.id ?? undefined;
+                this.options.onSent(s, message);
+                // Handle repeating jobs — re-arm instead of removing from the queue.
+                if (s.repeatIntervalMs && s.repeatIntervalMs > 0) {
+                    const nextCount = (s.repeatCount ?? 0) + 1;
+                    if (s.maxRepeats === undefined || nextCount < s.maxRepeats) {
+                        s.repeatCount = nextCount;
+                        s.scheduledTime = new Date(Date.now() + s.repeatIntervalMs);
+                        s.status = 'pending';
+                        continue;
+                    }
+                }
+                s.status = 'sent';
+            }
+            catch (error) {
+                s.status = 'failed';
+                s.error = error?.message || String(error);
+                this.options.onFailed(s, error);
+            }
+            this.queue.delete(id);
+        }
+        if (this.queue.size === 0)
+            this.stopTimer();
+    }
+    ensureTimerRunning() {
+        if (!this.timer) {
+            this.timer = setInterval(() => this.processQueue(), this.options.checkInterval);
+            this.timer?.unref?.();
+        }
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    stop() {
+        this.stopTimer();
+    }
+    start() {
+        if (this.queue.size > 0)
+            this.ensureTimerRunning();
+    }
+}
+export const createMessageScheduler = (sendMessage, options) => new MessageScheduler(sendMessage, options);

package/lib/Utils/signal.d.ts

@@ -0,0 +1,82 @@
+export function createSignalIdentity(wid: any, accountSignatureKey: any): {
+    identifier: {
+        name: any;
+        deviceId: number;
+    };
+    identifierKey: any;
+};
+export function getPreKeys({ get }: {
+    get: any;
+}, min: any, limit: any): Promise<any>;
+export function generateOrGetPreKeys(creds: any, range: any): {
+    newPreKeys: {};
+    lastPreKeyId: number;
+    preKeysRange: any[];
+};
+export function xmppSignedPreKey(key: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function xmppPreKey(pair: any, id: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function extractE2ESessionFromRetryReceipt(receipt: any): {
+    registrationId: number | undefined;
+    identityKey: any;
+    signedPreKey: {
+        keyId: number | undefined;
+        publicKey: any;
+        signature: any;
+    };
+    preKey: {
+        keyId: number | undefined;
+        publicKey: any;
+    } | undefined;
+} | null;
+export function parseAndInjectE2ESessions(node: any, repository: any): Promise<void>;
+export function extractDeviceJids(result: any, myJid: any, myLid: any, excludeZeroDevices: any): {
+    user: any;
+    device: any;
+    domainType: any;
+    server: any;
+}[];
+export function getNextPreKeys({ creds, keys }: {
+    creds: any;
+    keys: any;
+}, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    preKeys: any;
+}>;
+export function getNextPreKeysNode(state: any, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    node: {
+        tag: string;
+        attrs: {
+            xmlns: string;
+            type: string;
+            to: string;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    };
+}>;

package/lib/Utils/signal.js

@@ -0,0 +1,200 @@
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
+import { Curve, generateSignalPubKey } from './crypto.js';
+import { encodeBigEndian } from './generics.js';
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+export const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: generateSignalPubKey(accountSignatureKey)
+    };
+};
+export const getPreKeys = async ({ get }, min, limit) => {
+    const idList = [];
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString());
+    }
+    return get('pre-key', idList);
+};
+export const generateOrGetPreKeys = (creds, range) => {
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+    const remaining = range - avaliable;
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
+    const newPreKeys = {};
+    if (remaining > 0) {
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+            newPreKeys[i] = Curve.generateKeyPair();
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+    };
+};
+export const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+});
+export const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+});
+const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
+export const extractE2ESessionFromRetryReceipt = (receipt) => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys');
+    if (!keysNode)
+        return null;
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
+        return null;
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    const skey = getBinaryNodeChild(keysNode, 'skey');
+    if (!identity || identity.length !== 32 || !skey)
+        return null;
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
+    if (!isValidUInt(registrationId))
+        return null;
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+        return null;
+    }
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
+    let preKey;
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+            return null;
+        }
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
+    }
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: {
+            keyId: signedKeyId,
+            publicKey: generateSignalPubKey(signedPubKey),
+            signature: signedSig
+        },
+        preKey
+    };
+};
+export const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => key
+        ? {
+            keyId: getBinaryNodeChildUInt(key, 'id', 3),
+            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+            signature: getBinaryNodeChildBuffer(key, 'signature')
+        }
+        : undefined;
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+    for (const node of nodes) {
+        assertNodeErrorFree(node);
+    }
+    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
+    // So Promise.all doesn't really help here,
+    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
+    // It's rare case when you need to E2E sessions for so many users, but it's possible
+    const chunkSize = 100;
+    const chunks = chunk(nodes, chunkSize);
+    for (const nodesChunk of chunks) {
+        for (const node of nodesChunk) {
+            const signedKey = getBinaryNodeChild(node, 'skey');
+            const key = getBinaryNodeChild(node, 'key');
+            const identity = getBinaryNodeChildBuffer(node, 'identity');
+            const jid = node.attrs.jid;
+            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
+            await repository.injectE2ESession({
+                jid,
+                session: {
+                    registrationId: registrationId,
+                    identityKey: generateSignalPubKey(identity),
+                    signedPreKey: extractKey(signedKey),
+                    preKey: extractKey(key)
+                }
+            });
+        }
+    }
+};
+export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid);
+    const extracted = [];
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        const decoded = jidDecode(id), { user, server } = decoded;
+        let { domainType } = decoded;
+        const deviceList = devices?.deviceList;
+        if (!Array.isArray(deviceList))
+            continue;
+        for (const { id: device, keyIndex, isHosted } of deviceList) {
+            if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
+                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+            ) {
+                if (isHosted) {
+                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+                }
+                extracted.push({
+                    user,
+                    device,
+                    domainType,
+                    server: getServerFromDomainType(server, domainType)
+                });
+            }
+        }
+    }
+    return extracted;
+};
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+    const update = {
+        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+    };
+    await keys.set({ 'pre-key': newPreKeys });
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    return { update, preKeys };
+};
+export const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state;
+    const { update, preKeys } = await getNextPreKeys(state, count);
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: S_WHATSAPP_NET
+        },
+        content: [
+            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+            xmppSignedPreKey(creds.signedPreKey)
+        ]
+    };
+    return { update, node };
+};

package/lib/Utils/stanza-ack.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node: any, errorCode: any, meId: any): {
+    tag: string;
+    attrs: {
+        id: any;
+        to: any;
+        class: any;
+    };
+};

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,37 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}

package/lib/Utils/status.d.ts

@@ -0,0 +1,50 @@
+import type { AnyMessageContent } from '../Types/index.js';
+import type makeWASocket from '../Socket/index.js';
+type WASocket = ReturnType<typeof makeWASocket>;
+export declare const STATUS_BROADCAST_JID = "status@broadcast";
+export declare const STATUS_BACKGROUNDS: {
+    solid: Record<string, string>;
+    gradient: Record<string, string[]>;
+};
+export declare const STATUS_FONTS: {
+    readonly SANS_SERIF: 0;
+    readonly SERIF: 1;
+    readonly NORICAN: 2;
+    readonly BRYNDAN: 3;
+    readonly BEBASNEUE: 4;
+    readonly OSWALD: 5;
+    readonly DAMION: 6;
+    readonly DANCING: 7;
+    readonly COMFORTAA: 8;
+    readonly EXOTWO: 9;
+};
+export type StatusFont = (typeof STATUS_FONTS)[keyof typeof STATUS_FONTS];
+export declare const generateStatusMessageId: () => string;
+export type TextStatusOptions = {
+    text: string;
+    backgroundColor?: string;
+    font?: StatusFont;
+    textColor?: string;
+    mentions?: string[];
+};
+export type MediaStatusOptions = {
+    caption?: string;
+    gifPlayback?: boolean;
+    waveform?: Uint8Array;
+};
+export declare const createTextStatus: (options: TextStatusOptions) => AnyMessageContent;
+export declare const createImageStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createVideoStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createAudioStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const getStatusJid: () => string;
+export declare const StatusHelper: {
+    text: (text: string, backgroundColor?: string, font?: StatusFont) => AnyMessageContent;
+    image: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    imageUrl: (url: string, caption?: string) => AnyMessageContent;
+    video: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    videoUrl: (url: string, caption?: string) => AnyMessageContent;
+    gif: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    voiceNote: (buffer: Buffer) => AnyMessageContent;
+    send: (sock: WASocket, content: AnyMessageContent, jidList?: string[]) => Promise<any>;
+};
+export {};