zaileys 4.7.1 → 4.7.2

package/README.md

@@ -235,6 +235,11 @@ Zaileys ships dual ESM/CJS entry points with type declarations for both module s
 
 Package managers: **npm**, **pnpm**, **yarn**, and **bun** are all supported.
 
+### Bundling & typecheck troubleshooting
+
+- **`bun build` fails with "Browser build cannot import Node.js builtin"** — Zaileys (and baileys underneath) is a Node-only library; bun's bundler defaults to a browser target. Pass the target explicitly: `bun build index.ts --target bun` (or `--target node`).
+- **`tsc` reports errors inside `node_modules` (`ws`, `thread-stream`, `whatsapp-rust-bridge`)** — upstream declaration issues, not yours. Set `"skipLibCheck": true` in your `tsconfig.json`.
+
 ## Documentation
 
 - 🌐 [**zeative.github.io/zaileys**](https://zeative.github.io/zaileys/) — full documentation site: guides, API reference, recipes

package/dist/auth/adapters/convex.d.ts

@@ -0,0 +1,9 @@
+import { type ConvexKvOptions } from '../../types/convex.js';
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export type ConvexAuthStoreOptions = ConvexKvOptions;
+export declare class ConvexAuthStore implements AuthStoreBundle {
+    readonly creds: AuthCredsStore;
+    readonly signal: AuthStore;
+    private readonly kv;
+    constructor(options: ConvexAuthStoreOptions);
+}

package/dist/auth/adapters/file.d.ts

@@ -0,0 +1,16 @@
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export interface FileAuthStoreOptions {
+    basePath?: string;
+}
+export declare class FileAuthStore implements AuthStoreBundle {
+    private readonly basePath;
+    private closed;
+    constructor(options?: FileAuthStoreOptions);
+    readonly signal: AuthStore;
+    readonly creds: AuthCredsStore;
+    private credsPath;
+    private signalDir;
+    private signalPath;
+    private atomicWrite;
+    private assertOpen;
+}

package/dist/auth/adapters/index.d.ts

@@ -0,0 +1,6 @@
+export * from './memory.js';
+export * from './file.js';
+export * from './sqlite.js';
+export * from './postgres.js';
+export * from './redis.js';
+export * from './convex.js';

package/dist/auth/adapters/memory.d.ts

@@ -0,0 +1,9 @@
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export declare class MemoryAuthStore implements AuthStoreBundle {
+    private credsBlob;
+    private readonly signalMap;
+    private closed;
+    readonly signal: AuthStore;
+    readonly creds: AuthCredsStore;
+    private assertOpen;
+}

package/dist/auth/adapters/postgres.d.ts

@@ -0,0 +1,20 @@
+import type { PgPoolLike } from '../../types/optional-clients.js';
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export interface PostgresAuthStoreOptions {
+    pool?: PgPoolLike;
+    connectionString?: string;
+    max?: number;
+}
+export declare class PostgresAuthStore implements AuthStoreBundle {
+    private readonly externalPool;
+    private readonly connectionString;
+    private readonly poolMax;
+    private ownedPool;
+    private resolvedPool;
+    private readyPromise;
+    private closed;
+    constructor(options: PostgresAuthStoreOptions);
+    private ensureReady;
+    readonly signal: AuthStore;
+    readonly creds: AuthCredsStore;
+}

package/dist/auth/adapters/redis.d.ts

@@ -0,0 +1,27 @@
+import type { RedisClientLike } from '../../types/optional-clients.js';
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export interface RedisAuthStoreOptions {
+    client?: RedisClientLike;
+    url?: string;
+    namespace?: string;
+}
+export declare class RedisAuthStore implements AuthStoreBundle {
+    private readonly namespace;
+    private readonly externalClient;
+    private readonly url;
+    private ownedClient;
+    private ready;
+    private closed;
+    constructor(options: RedisAuthStoreOptions);
+    readonly signal: AuthStore;
+    readonly creds: AuthCredsStore;
+    private credsKey;
+    private signalKey;
+    private indexKey;
+    private ensureReady;
+    private connect;
+    private runRead;
+    private runWrite;
+    private shutdown;
+    private assertOpen;
+}

package/dist/auth/adapters/sqlite.d.ts

@@ -0,0 +1,19 @@
+import type { AuthCredsStore, AuthStore, AuthStoreBundle } from '../types.js';
+export interface SqliteAuthStoreOptions {
+    database: string | Buffer;
+    readonly?: boolean;
+}
+export declare class SqliteAuthStore implements AuthStoreBundle {
+    private readonly options;
+    private db;
+    private prepared;
+    private readyPromise;
+    private closed;
+    constructor(options: SqliteAuthStoreOptions);
+    readonly creds: AuthCredsStore;
+    readonly signal: AuthStore;
+    private ensureReady;
+    private openAndMigrate;
+    private encodeBlob;
+    private parseBlob;
+}

package/dist/auth/cache.d.ts

@@ -0,0 +1,11 @@
+import type { AuthStoreBundle } from './types.js';
+export interface CacheableAuthStoreOptions {
+    logger?: {
+        trace?: (msg: unknown) => void;
+        debug?: (msg: unknown) => void;
+        info?: (msg: unknown) => void;
+        warn?: (msg: unknown) => void;
+        error?: (msg: unknown) => void;
+    };
+}
+export declare function makeCacheableAuthStore(bundle: AuthStoreBundle, options?: CacheableAuthStoreOptions): AuthStoreBundle;

package/dist/auth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './adapters/index.js';
+export * from './cache.js';

package/dist/auth/types.d.ts

@@ -0,0 +1,21 @@
+import type { AuthenticationCreds, SignalDataSet, SignalDataTypeMap } from 'baileys';
+export type AuthStoreKey = keyof SignalDataTypeMap;
+export type AuthStoreValue<K extends AuthStoreKey> = SignalDataTypeMap[K];
+export interface AuthStore {
+    read<K extends AuthStoreKey>(type: K, ids: readonly string[]): Promise<{
+        [id: string]: AuthStoreValue<K> | undefined;
+    }>;
+    write(data: SignalDataSet): Promise<void>;
+    delete<K extends AuthStoreKey>(type: K, ids: readonly string[]): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface AuthCredsStore {
+    readCreds(): Promise<AuthenticationCreds | undefined>;
+    writeCreds(creds: AuthenticationCreds): Promise<void>;
+    deleteCreds(): Promise<void>;
+}
+export interface AuthStoreBundle {
+    readonly creds: AuthCredsStore;
+    readonly signal: AuthStore;
+}

package/dist/automation/auto-delete.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from '../client/types.js';
+import type { MessageStore, PruneOptions } from '../store/types.js';
+export type AutoDeleteOptions = {
+    maxAgeMs?: number;
+    maxPerChat?: number;
+    intervalMs?: number;
+    chats?: 'all' | ((jid: string) => boolean);
+};
+export declare function genericPrune(store: MessageStore, opts: PruneOptions): Promise<number>;
+export declare class AutoDeleteSweeper {
+    private readonly store;
+    private readonly options;
+    private readonly logger;
+    private readonly now;
+    private timer;
+    private running;
+    private warnedUnsupported;
+    private disabled;
+    constructor(deps: {
+        store: MessageStore;
+        options: AutoDeleteOptions;
+        logger?: Logger;
+        now?: () => number;
+    });
+    private get active();
+    private buildPruneOptions;
+    runOnce(): Promise<number>;
+    start(): void;
+    stop(): void;
+}

package/dist/automation/broadcast.d.ts

@@ -0,0 +1,10 @@
+import type { MessageBuilder } from '../builder/builder.js';
+import { RateLimiter } from './rate-limiter.js';
+import type { BroadcastOptions, BroadcastResult } from './types.js';
+export type BroadcastDeps = {
+    sendTo: (jid: string) => MessageBuilder<'init'>;
+    limiter?: RateLimiter;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+};
+export declare function runBroadcast(jids: string[], build: (b: MessageBuilder<'init'>) => MessageBuilder<'content-set'>, deps: BroadcastDeps, options?: BroadcastOptions): Promise<BroadcastResult>;

package/dist/automation/errors.d.ts

@@ -0,0 +1,8 @@
+export type AutomationErrorCode = 'NOT_CONNECTED' | 'RATE_LIMIT_INVALID' | 'TASK_FAILED' | 'SCHEDULE_INVALID' | 'STORE_UNAVAILABLE' | 'PRESENCE_FAILED';
+export declare class ZaileysAutomationError extends Error {
+    readonly code: AutomationErrorCode;
+    readonly cause?: unknown;
+    constructor(code: AutomationErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/automation/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './errors.js';
+export { RateLimiter, type RateLimiterClock } from './rate-limiter.js';
+export { createOperationGuard, type OperationGuard, type OperationGuardOptions, type OperationGuardClock, type OperationCategory, } from './operation-guard.js';
+export { TaskQueue, type TaskQueueClock } from './queue.js';
+export { runBroadcast, type BroadcastDeps } from './broadcast.js';
+export { PresenceModule, type AutomationSocketLike, type WAPresence, type PresenceThrottleOptions, type PresenceClock, } from './presence.js';
+export { Scheduler, type SchedulerDeps, type SchedulerTimer, type ScheduleHandle, type ScheduledContentSnapshot, } from './schedule.js';
+export type { ScheduledJobRecord } from '../store/types.js';
+export { AutoDeleteSweeper, genericPrune } from './auto-delete.js';
+export type { AutoDeleteOptions } from './auto-delete.js';

package/dist/automation/operation-guard.d.ts

@@ -0,0 +1,20 @@
+export type OperationGuardClock = {
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Per-category minimum-interval throttle for sensitive account operations
+ * (group/community/newsletter create, join, member changes). Spacing these out
+ * avoids the rapid-fire pattern WhatsApp flags as automated/bulk abuse.
+ */
+export type OperationCategory = 'group.create' | 'group.join' | 'group.participants' | 'group.update' | 'community.create' | 'community.join' | 'community.update' | 'newsletter.create' | 'newsletter.follow' | 'newsletter.update';
+export interface OperationGuardOptions {
+    /** Master switch. When `false` operations run with no spacing. Default `true`. */
+    enabled?: boolean;
+    /** Per-category minimum interval in ms, overriding the built-in defaults. */
+    intervalsMs?: Partial<Record<OperationCategory, number>>;
+}
+export interface OperationGuard {
+    run<T>(category: OperationCategory, op: () => Promise<T>): Promise<T>;
+}
+export declare function createOperationGuard(options?: OperationGuardOptions, clock?: OperationGuardClock): OperationGuard;

package/dist/automation/presence.d.ts

@@ -0,0 +1,28 @@
+export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export interface AutomationSocketLike {
+    sendPresenceUpdate(type: WAPresence, toJid?: string): Promise<void>;
+}
+/** Drops presence updates that repeat the same (type, chat) inside `minIntervalMs`. */
+export interface PresenceThrottleOptions {
+    enabled?: boolean;
+    minIntervalMs?: number;
+}
+export type PresenceClock = {
+    now?: () => number;
+};
+export declare class PresenceModule {
+    private readonly getSocket;
+    private readonly throttleEnabled;
+    private readonly minIntervalMs;
+    private readonly now;
+    private readonly lastSent;
+    constructor(getSocket: () => AutomationSocketLike | undefined, throttle?: PresenceThrottleOptions, clock?: PresenceClock);
+    protected requireSocket(): AutomationSocketLike;
+    private throttled;
+    private update;
+    private scheduleClear;
+    online(): Promise<void>;
+    offline(): Promise<void>;
+    typing(jid: string, ms?: number): Promise<void>;
+    recording(jid: string, ms?: number): Promise<void>;
+}

package/dist/automation/queue.d.ts

@@ -0,0 +1,18 @@
+import type { TaskQueueOptions } from './types.js';
+export type TaskQueueClock = {
+    sleep?: (ms: number) => Promise<void>;
+};
+export declare class TaskQueue {
+    private readonly concurrency;
+    private readonly retry;
+    private readonly sleep;
+    private readonly pending;
+    private active;
+    private idleWaiters;
+    constructor(options?: TaskQueueOptions, clock?: TaskQueueClock);
+    add<T>(task: () => Promise<T>): Promise<T>;
+    onIdle(): Promise<void>;
+    private pump;
+    private settleIdle;
+    private execute;
+}

package/dist/automation/rate-limiter.d.ts

@@ -0,0 +1,18 @@
+import type { RateLimiterOptions } from './types.js';
+export type RateLimiterClock = {
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+};
+export declare class RateLimiter {
+    private readonly now;
+    private readonly sleep;
+    private readonly perJidRatePerMs?;
+    private readonly perJidCapacity?;
+    private readonly global;
+    private readonly perJid;
+    constructor(options: RateLimiterOptions, clock?: RateLimiterClock);
+    acquire(jid?: string): Promise<void>;
+    private bucketFor;
+    private consume;
+    private refill;
+}

package/dist/automation/schedule.d.ts

@@ -0,0 +1,45 @@
+import type { AnyMessageContent, MiscMessageGenerationOptions } from 'baileys';
+import { MessageBuilder } from '../builder/builder.js';
+import type { MessageStore } from '../store/types.js';
+import type { Logger } from '../client/types.js';
+export type ScheduledContentSnapshot = {
+    recipient: string;
+    content: AnyMessageContent;
+    options?: MiscMessageGenerationOptions;
+};
+export type SchedulerTimer = {
+    set: (cb: () => void, ms: number) => unknown;
+    clear: (handle: unknown) => void;
+};
+export type SchedulerDeps = {
+    store: MessageStore;
+    sendSnapshot: (snapshot: ScheduledContentSnapshot) => Promise<void>;
+    now?: () => number;
+    timer?: SchedulerTimer;
+    logger?: Logger;
+    acquire?: () => Promise<void>;
+};
+export type ScheduleHandle = {
+    id: string;
+    cancel(): void;
+};
+export declare class Scheduler {
+    private readonly store;
+    private readonly sendSnapshot;
+    private readonly now;
+    private readonly timer;
+    private readonly logger;
+    private readonly acquire;
+    private readonly memory;
+    private readonly timers;
+    constructor(deps: SchedulerDeps);
+    scheduleAt(date: Date, build: (b: MessageBuilder<'init'>) => MessageBuilder<'content-set'>): Promise<ScheduleHandle>;
+    loadPending(): Promise<void>;
+    dispose(): void;
+    private cancel;
+    private arm;
+    private fire;
+    private persist;
+    private remove;
+    private evaluate;
+}

package/dist/automation/types.d.ts

@@ -0,0 +1,31 @@
+export type RateLimiterOptions = {
+    perSec: number;
+    perJidPerSec?: number;
+    burst?: number;
+};
+export type RetryPolicy = {
+    maxRetries: number;
+    backoffMs: (attempt: number) => number;
+};
+export type TaskQueueOptions = {
+    concurrency?: number;
+    retry?: RetryPolicy;
+};
+export type BroadcastOptions = {
+    rateLimitPerSec?: number;
+    retry?: RetryPolicy;
+    onProgress?: (done: number, total: number, jid: string, ok: boolean) => void;
+};
+export type BroadcastResult = {
+    sent: string[];
+    failed: {
+        jid: string;
+        error: Error;
+    }[];
+};
+export type ScheduledJob = {
+    id: string;
+    fireAt: number;
+    recipient: string;
+    payload: unknown;
+};

package/dist/builder/album.d.ts

@@ -0,0 +1,4 @@
+import type { WAMessageKey } from 'baileys';
+import type { BuilderSocketLike } from './builder.js';
+import type { AlbumItem, BuilderContext } from './types.js';
+export declare const sendAlbum: (socket: BuilderSocketLike, recipient: string, items: AlbumItem[], context: BuilderContext) => Promise<WAMessageKey>;

package/dist/builder/builder.d.ts

@@ -0,0 +1,59 @@
+import { type AnyMessageContent, type MiscMessageGenerationOptions, type WAMessage, type WAMessageKey } from 'baileys';
+import { type ButtonsContentOptions } from './content/buttons.js';
+import { type CarouselCard } from './content/carousel.js';
+import { type AIRichOptions } from './content/airich.js';
+import { type BuilderInternalState } from './state.js';
+import type { AlbumItem, AudioOptions, BuilderState, ButtonDef, DocumentOptions, EventOptions, GroupInviteOptions, ImageOptions, InteractiveButton, ListOptions, LocationOptions, MediaSource, PollOptions, ProductOptions, StickerOptions, TemplateOptions, VideoNoteOptions, VideoOptions } from './types.js';
+export interface BuilderSocketLike {
+    sendMessage(jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions): Promise<WAMessage | undefined>;
+    relayMessage?(jid: string, message: unknown, options: {
+        messageId: string;
+        additionalNodes?: unknown[];
+    }): Promise<string>;
+    chatModify?(mod: unknown, jid: string): Promise<void>;
+    user?: {
+        id?: string | null;
+    } | null;
+    waUploadToServer?: unknown;
+}
+export type TextOptions = {
+    rich?: boolean;
+} & AIRichOptions;
+export declare class MessageBuilder<State extends BuilderState> {
+    protected readonly __state?: State;
+    protected readonly socket: BuilderSocketLike;
+    protected readonly internal: BuilderInternalState;
+    constructor(socket: BuilderSocketLike, internal: BuilderInternalState);
+    static create(socket: BuilderSocketLike, recipient: string, resolveRecipient?: (raw: string) => Promise<string>, recordSent?: (message: WAMessage) => void): MessageBuilder<'init'>;
+    to(this: MessageBuilder<'init'>, recipient: string): MessageBuilder<'init'>;
+    text(this: MessageBuilder<'init'>, content: string, opts?: TextOptions): MessageBuilder<'content-set'>;
+    image(this: MessageBuilder<'init'>, src: MediaSource, opts?: ImageOptions): MessageBuilder<'content-set'>;
+    videoNote(this: MessageBuilder<'init'>, src: MediaSource, opts?: VideoNoteOptions): MessageBuilder<'content-set'>;
+    video(this: MessageBuilder<'init'>, src: MediaSource, opts?: VideoOptions): MessageBuilder<'content-set'>;
+    audio(this: MessageBuilder<'init'>, src: MediaSource, opts?: AudioOptions): MessageBuilder<'content-set'>;
+    document(this: MessageBuilder<'init'>, src: MediaSource, opts: DocumentOptions): MessageBuilder<'content-set'>;
+    sticker(this: MessageBuilder<'init'>, src: MediaSource, opts?: StickerOptions): MessageBuilder<'content-set'>;
+    buttons(this: MessageBuilder<'init'>, buttons: Array<ButtonDef | InteractiveButton>, opts?: ButtonsContentOptions): MessageBuilder<'content-set'>;
+    carousel(this: MessageBuilder<'init'>, cards: CarouselCard[], opts?: {
+        text?: string;
+    }): MessageBuilder<'content-set'>;
+    list(this: MessageBuilder<'init'>, opts: ListOptions): MessageBuilder<'content-set'>;
+    poll(this: MessageBuilder<'init'>, question: string, options: string[], opts?: PollOptions): MessageBuilder<'content-set'>;
+    location(this: MessageBuilder<'init'>, lat: number, lon: number, opts?: LocationOptions): MessageBuilder<'content-set'>;
+    contact(this: MessageBuilder<'init'>, vcard: string): MessageBuilder<'content-set'>;
+    template(this: MessageBuilder<'init'>, opts: TemplateOptions): MessageBuilder<'content-set'>;
+    event(this: MessageBuilder<'init'>, opts: EventOptions): MessageBuilder<'content-set'>;
+    groupInvite(this: MessageBuilder<'init'>, opts: GroupInviteOptions): MessageBuilder<'content-set'>;
+    product(this: MessageBuilder<'init'>, opts: ProductOptions): MessageBuilder<'content-set'>;
+    requestPhoneNumber(this: MessageBuilder<'init'>): MessageBuilder<'content-set'>;
+    sharePhoneNumber(this: MessageBuilder<'init'>): MessageBuilder<'content-set'>;
+    limitSharing(this: MessageBuilder<'init'>, enabled?: boolean): MessageBuilder<'content-set'>;
+    album(this: MessageBuilder<'init'>, items: AlbumItem[]): MessageBuilder<'content-set'>;
+    reply(quoted: WAMessage | WAMessageKey): MessageBuilder<State>;
+    mentions(jids: string[]): MessageBuilder<State>;
+    mentionAll(): MessageBuilder<State>;
+    disappearing(seconds: number): MessageBuilder<State>;
+    then<T = WAMessageKey>(this: MessageBuilder<'content-set'>, onResolved: (key: WAMessageKey) => T, onRejected?: (err: unknown) => T | PromiseLike<T>): Promise<T>;
+    private uploadHeaderMedia;
+    private sendRelay;
+}

package/dist/builder/content/airich.d.ts

@@ -0,0 +1,80 @@
+import type { AnyMessageContent } from 'baileys';
+export type AIRichPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'code';
+    language?: string;
+    content: string;
+} | {
+    type: 'table';
+    rows: string[][];
+} | {
+    type: 'image';
+    url: string | string[];
+} | {
+    type: 'video';
+    url: string | string[];
+    duration?: number;
+} | {
+    type: 'product';
+    products: AIRichProduct | AIRichProduct[];
+} | {
+    type: 'reels';
+    reels: AIRichReel | AIRichReel[];
+} | {
+    type: 'post';
+    posts: AIRichPost | AIRichPost[];
+} | {
+    type: 'tip';
+    text: string;
+} | {
+    type: 'suggest';
+    prompts: string | string[];
+};
+export type AIRichProduct = {
+    title: string;
+    price?: string;
+    salePrice?: string;
+    brand?: string;
+    url?: string;
+    image?: string;
+    icon?: string;
+};
+export type AIRichReel = {
+    username?: string;
+    title?: string;
+    profileUrl?: string;
+    thumbnail?: string;
+    url?: string;
+    likes?: number;
+    shares?: number;
+    views?: number;
+    source?: string;
+    verified?: boolean;
+};
+export type AIRichPost = {
+    title?: string;
+    subtitle?: string;
+    username?: string;
+    profileUrl?: string;
+    verified?: boolean;
+    thumbnail?: string;
+    caption?: string;
+    likes?: number;
+    comments?: number;
+    shares?: number;
+    url?: string;
+    deeplink?: string;
+    source?: string;
+    footer?: string;
+    icon?: string;
+    orientation?: string;
+    postType?: string;
+};
+export type AIRichOptions = {
+    title?: string;
+    footer?: string;
+    sources?: Array<[profileUrl: string, url: string, text: string]>;
+};
+export declare const buildAIRichContent: (parts: AIRichPart[], opts?: AIRichOptions) => AnyMessageContent;

package/dist/builder/content/audio.d.ts

@@ -0,0 +1,9 @@
+import type { AnyMessageContent } from 'baileys';
+import type { AudioOptions, MediaSource } from '../types.js';
+export type AudioContent = {
+    audio: Buffer;
+    ptt?: boolean;
+    seconds?: number;
+    waveform?: Uint8Array;
+};
+export declare const buildAudioContent: (src: MediaSource, opts?: AudioOptions) => Promise<AnyMessageContent>;

package/dist/builder/content/buttons.d.ts

@@ -0,0 +1,30 @@
+import { proto, type AnyMessageContent } from 'baileys';
+import type { BottomSheetOptions, ButtonDef, InteractiveButton, LimitedTimeOfferOptions, MediaSource } from '../types.js';
+export declare const RELAY_CONTENT_KEY = "__zaileysRelayMessage";
+export declare const RELAY_MEDIA_KEY = "__zaileysHeaderMedia";
+export type HeaderMedia = {
+    kind: 'image' | 'video';
+    src: MediaSource;
+};
+export type RelayContent = {
+    [RELAY_CONTENT_KEY]: proto.IMessage;
+    [RELAY_MEDIA_KEY]?: HeaderMedia;
+};
+export type ButtonsContentOptions = {
+    text?: string;
+    footer?: string;
+    title?: string;
+    subtitle?: string;
+    image?: MediaSource;
+    video?: MediaSource;
+    bottomSheet?: BottomSheetOptions;
+    limitedTimeOffer?: LimitedTimeOfferOptions;
+};
+type NativeButton = {
+    name: string;
+    buttonParamsJson: string;
+};
+export declare const buildMessageParamsJson: (opts?: ButtonsContentOptions) => string;
+export declare const buildNativeButtons: (buttons: Array<ButtonDef | InteractiveButton>) => NativeButton[];
+export declare const buildButtonsContent: (buttons: Array<ButtonDef | InteractiveButton>, opts?: ButtonsContentOptions) => AnyMessageContent;
+export {};

package/dist/builder/content/carousel.d.ts

@@ -0,0 +1,19 @@
+import { type AnyMessageContent } from 'baileys';
+import type { ButtonDef, InteractiveButton, MediaSource } from '../types.js';
+import { type HeaderMedia } from './buttons.js';
+export declare const RELAY_CARDS_MEDIA_KEY = "__zaileysCardsMedia";
+export type CardMedia = HeaderMedia & {
+    index: number;
+};
+export type CarouselCard = {
+    title?: string;
+    subtitle?: string;
+    body?: string;
+    footer?: string;
+    image?: MediaSource;
+    video?: MediaSource;
+    buttons?: Array<ButtonDef | InteractiveButton>;
+};
+export declare const buildCarouselContent: (cards: CarouselCard[], opts?: {
+    text?: string;
+}) => AnyMessageContent;

package/dist/builder/content/contact.d.ts

@@ -0,0 +1,13 @@
+import type { AnyMessageContent } from 'baileys';
+export type ContactContentOptions = {
+    displayName?: string;
+};
+export type ContactContent = {
+    contacts: {
+        displayName?: string;
+        contacts: Array<{
+            vcard: string;
+        }>;
+    };
+};
+export declare const buildContactContent: (vcard: string, opts?: ContactContentOptions) => AnyMessageContent;

package/dist/builder/content/document.d.ts

@@ -0,0 +1,9 @@
+import type { AnyMessageContent } from 'baileys';
+import type { DocumentOptions, MediaSource } from '../types.js';
+export type DocumentContent = {
+    document: Buffer;
+    fileName: string;
+    mimetype: string;
+    caption?: string;
+};
+export declare const buildDocumentContent: (src: MediaSource, opts: DocumentOptions) => Promise<AnyMessageContent>;

package/dist/builder/content/event.d.ts

@@ -0,0 +1,3 @@
+import type { AnyMessageContent } from 'baileys';
+import type { EventOptions } from '../types.js';
+export declare const buildEventContent: (opts: EventOptions) => AnyMessageContent;

package/dist/builder/content/group-invite.d.ts

@@ -0,0 +1,3 @@
+import type { AnyMessageContent } from 'baileys';
+import type { GroupInviteOptions } from '../types.js';
+export declare const buildGroupInviteContent: (opts: GroupInviteOptions) => AnyMessageContent;

package/dist/builder/content/image.d.ts

@@ -0,0 +1,8 @@
+import type { AnyMessageContent } from 'baileys';
+import type { ImageOptions, MediaSource } from '../types.js';
+export type ImageContent = {
+    image: Buffer;
+    caption?: string;
+    viewOnce?: boolean;
+};
+export declare const buildImageContent: (src: MediaSource, opts?: ImageOptions) => Promise<AnyMessageContent>;