zaileys 4.7.1 → 4.8.0

package/dist/cloud/index.d.ts

@@ -0,0 +1,6 @@
+export { ZaileysCloudError, ZaileysProviderError, type CloudErrorCode } from './errors.js';
+export { validateCloudOptions, type CloudOptions } from './types.js';
+export { CloudTransport, DEFAULT_GRAPH_VERSION } from './transport.js';
+export { CloudModule, type CloudTemplate, type CloudBusinessProfile, type FlowSendOptions } from './module.js';
+export { createWebhookHandler, type WebhookHandler, type WebhookHandlerOptions } from './webhook.js';
+export type { CloudFlowResponseEvent, CloudMessageStatus, CloudOrderEvent, CloudStatusEvent, CloudTemplateStatusEvent, } from './translate/inbound.js';

package/dist/cloud/media.d.ts

@@ -0,0 +1,15 @@
+import type { AnyMessageContent } from 'baileys';
+import type { GraphClient } from './graph-client.js';
+export type CloudMediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker';
+export interface OutboundMedia {
+    kind: CloudMediaKind;
+    buffer: Buffer;
+    caption?: string;
+    fileName?: string;
+    mimetype?: string;
+}
+/** Detect a builder media content (`{ image: Buffer, caption? }` etc.); null when not media. */
+export declare function outboundMediaOf(content: AnyMessageContent): OutboundMedia | null;
+/** Upload bytes to the Cloud media endpoint; returns the media id to reference in sends. */
+export declare function uploadMedia(graph: GraphClient, phoneNumberId: string, media: OutboundMedia): Promise<string>;
+export declare function mediaMessageBody(media: OutboundMedia, mediaId: string): Record<string, unknown>;

package/dist/cloud/module.d.ts

@@ -0,0 +1,147 @@
+import type { WAMessageKey } from 'baileys';
+import type { CloudTransport } from './transport.js';
+import type { CloudOptions } from './types.js';
+export interface FlowSendOptions {
+    flowId?: string;
+    flowName?: string;
+    cta: string;
+    bodyText: string;
+    headerText?: string;
+    footerText?: string;
+    screen: string;
+    flowToken?: string;
+    data?: Record<string, unknown>;
+    mode?: 'draft' | 'published';
+    action?: 'navigate' | 'data_exchange';
+}
+export interface CloudTemplate {
+    id: string;
+    name: string;
+    status: string;
+    category?: string;
+    language?: string;
+    components?: Array<Record<string, unknown>>;
+}
+export interface CloudBusinessProfile {
+    about?: string;
+    address?: string;
+    description?: string;
+    email?: string;
+    websites?: string[];
+    vertical?: string;
+    messaging_product?: string;
+}
+/** Cloud-only management surface: templates, profile, flows, commerce, blocklist, qr, analytics, phone. */
+export declare class CloudModule {
+    private readonly graph;
+    private readonly options;
+    private readonly getTransport;
+    constructor(options: CloudOptions, getTransport: () => CloudTransport);
+    private requireWaba;
+    /** This sender's phone-number node: display number, verified name, quality rating, throughput. */
+    info(): Promise<Record<string, unknown>>;
+    /** All phone numbers registered under the WhatsApp Business Account. */
+    phoneNumbers(): Promise<Array<Record<string, unknown>>>;
+    /** Request the user's shipping address (interactive address_message; ID/BR only per Meta). */
+    sendAddressRequest(to: string, opts: {
+        bodyText: string;
+        countryIso: string;
+        values?: Record<string, unknown>;
+    }): Promise<WAMessageKey>;
+    readonly commerce: {
+        catalogs: () => Promise<Array<{
+            id: string;
+            name: string;
+        }>>;
+        products: (catalogId: string, limit?: number) => Promise<Array<{
+            id: string;
+            retailer_id: string;
+            name: string;
+            price?: string;
+            availability?: string;
+        }>>;
+        sendProduct: (to: string, opts: {
+            catalogId: string;
+            retailerId: string;
+            bodyText?: string;
+            footerText?: string;
+        }) => Promise<WAMessageKey>;
+        sendProductList: (to: string, opts: {
+            catalogId: string;
+            headerText: string;
+            bodyText: string;
+            footerText?: string;
+            sections: Array<{
+                title: string;
+                productIds: string[];
+            }>;
+        }) => Promise<WAMessageKey>;
+    };
+    readonly templates: {
+        list: (params?: {
+            status?: string;
+            limit?: number;
+        }) => Promise<CloudTemplate[]>;
+        get: (idOrName: string) => Promise<CloudTemplate | null>;
+        create: (template: {
+            name: string;
+            category: 'MARKETING' | 'UTILITY' | 'AUTHENTICATION';
+            language: string;
+            components: Array<Record<string, unknown>>;
+        }) => Promise<{
+            id: string;
+            status: string;
+        }>;
+        delete: (name: string, id?: string) => Promise<void>;
+    };
+    readonly profile: {
+        get: () => Promise<CloudBusinessProfile>;
+        update: (fields: CloudBusinessProfile) => Promise<void>;
+    };
+    readonly flows: {
+        list: () => Promise<Array<{
+            id: string;
+            name: string;
+            status: string;
+        }>>;
+        send: (to: string, opts: FlowSendOptions) => Promise<WAMessageKey>;
+    };
+    readonly blocklist: {
+        add: (numbers: string[]) => Promise<void>;
+        remove: (numbers: string[]) => Promise<void>;
+        list: () => Promise<Array<{
+            wa_id: string;
+        }>>;
+    };
+    readonly qr: {
+        create: (prefilledMessage: string, imageFormat?: 'SVG' | 'PNG') => Promise<{
+            code: string;
+            prefilled_message: string;
+            qr_image_url?: string;
+        }>;
+        list: () => Promise<Array<{
+            code: string;
+            prefilled_message: string;
+        }>>;
+        delete: (code: string) => Promise<void>;
+    };
+    readonly analytics: {
+        conversations: (params: {
+            start: number;
+            end: number;
+            granularity?: 'HALF_HOUR' | 'DAILY' | 'MONTHLY';
+        }) => Promise<unknown>;
+        messages: (params: {
+            start: number;
+            end: number;
+            granularity?: 'HALF_HOUR' | 'DAY' | 'MONTH';
+        }) => Promise<unknown>;
+    };
+    readonly phone: {
+        /** Registers the number for Cloud API messaging. Touches live registration — use with care. */
+        register: (pin: string) => Promise<void>;
+        deregister: () => Promise<void>;
+        requestCode: (method: 'SMS' | 'VOICE', language?: string) => Promise<void>;
+        verifyCode: (code: string) => Promise<void>;
+    };
+}

package/dist/cloud/translate/inbound.d.ts

@@ -0,0 +1,119 @@
+import type { WAMessage } from 'baileys';
+export interface CloudInboundMedia {
+    id?: string;
+    mime_type?: string;
+    sha256?: string;
+    caption?: string;
+    filename?: string;
+    voice?: boolean;
+    animated?: boolean;
+}
+export interface CloudWebhookMessage {
+    from?: string;
+    id?: string;
+    timestamp?: string;
+    type?: string;
+    text?: {
+        body?: string;
+    };
+    image?: CloudInboundMedia;
+    video?: CloudInboundMedia;
+    audio?: CloudInboundMedia;
+    document?: CloudInboundMedia;
+    sticker?: CloudInboundMedia;
+    [key: string]: unknown;
+}
+export interface CloudWebhookValue {
+    messaging_product?: string;
+    metadata?: {
+        display_phone_number?: string;
+        phone_number_id?: string;
+    };
+    contacts?: Array<{
+        profile?: {
+            name?: string;
+        };
+        wa_id?: string;
+    }>;
+    messages?: CloudWebhookMessage[];
+    statuses?: Array<Record<string, unknown>>;
+}
+export interface CloudWebhookPayload {
+    object?: string;
+    entry?: Array<{
+        id?: string;
+        changes?: Array<{
+            value?: CloudWebhookValue;
+            field?: string;
+        }>;
+    }>;
+}
+export interface CloudTemplateStatusEvent {
+    event: string;
+    id: string;
+    name: string;
+    language?: string;
+    reason?: string;
+}
+export type CloudMessageStatus = 'sent' | 'delivered' | 'read' | 'failed';
+export interface CloudStatusEvent {
+    id: string;
+    status: CloudMessageStatus;
+    recipientId: string;
+    timestamp: number;
+    conversationId?: string;
+    error?: {
+        code?: number;
+        title?: string;
+        message?: string;
+    };
+}
+export interface CloudFlowResponseEvent {
+    id: string;
+    name: string;
+    body?: string;
+    response: Record<string, unknown>;
+    senderId: string;
+    senderName?: string;
+    timestamp: number;
+}
+export interface CloudOrderEvent {
+    id: string;
+    catalogId: string;
+    text?: string;
+    items: Array<{
+        productRetailerId: string;
+        quantity: number;
+        price: number;
+        currency: string;
+    }>;
+    senderId: string;
+    senderName?: string;
+    timestamp: number;
+}
+export interface CloudReactionItem {
+    key: {
+        id: string;
+        remoteJid: string;
+        fromMe: boolean;
+    };
+    reaction: {
+        key: {
+            id: string;
+            remoteJid: string;
+            fromMe: boolean;
+        };
+        text: string;
+        senderTimestampMs: number;
+    };
+    pushName?: string;
+}
+/** Flatten a Meta webhook delivery into baileys-shaped events the existing pipeline can decode. */
+export declare function translateInbound(payload: CloudWebhookPayload): {
+    messages: WAMessage[];
+    reactions: CloudReactionItem[];
+    statuses: CloudStatusEvent[];
+    templateStatuses: CloudTemplateStatusEvent[];
+    flowResponses: CloudFlowResponseEvent[];
+    orders: CloudOrderEvent[];
+};

package/dist/cloud/translate/interactive.d.ts

@@ -0,0 +1,2 @@
+/** Translate the builder's relay proto (interactiveMessage) into a Graph `interactive` object. */
+export declare function translateInteractiveProto(message: Record<string, unknown>): Record<string, unknown> | null;

package/dist/cloud/translate/outbound.d.ts

@@ -0,0 +1,21 @@
+import type { AnyMessageContent, MiscMessageGenerationOptions, WAMessage } from 'baileys';
+export interface GraphMessagePayload {
+    messaging_product: 'whatsapp';
+    recipient_type: 'individual';
+    to: string;
+    type: string;
+    context?: {
+        message_id: string;
+    };
+    [key: string]: unknown;
+}
+/** Graph `to` is a bare number — strip any jid server suffix. */
+export declare const toGraphRecipient: (to: string) => string;
+export declare const toJid: (recipient: string) => string;
+export declare const basePayload: (to: string, type: string, options?: MiscMessageGenerationOptions) => GraphMessagePayload;
+/** Translate baileys-style outbound content to a Graph payload; null = not translatable yet. */
+export declare function translateOutbound(to: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions): GraphMessagePayload | null;
+/** Minimal vcard extraction (FN/N + TELs) — Graph requires formatted_name plus one name part. */
+export declare function vcardToGraphContact(vcard: string): Record<string, unknown> | null;
+/** Minimal baileys-shaped WAMessage so recordSent/store/reply keep working on cloud. */
+export declare function synthesizeSentMessage(wamid: string, to: string, content: AnyMessageContent, timestampMs: number): WAMessage;

package/dist/cloud/transport.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'node:events';
+import type { AnyMessageContent, MiscMessageGenerationOptions, WAMessage } from 'baileys';
+import type { Transport } from '../transport/types.js';
+import type { CloudOptions } from './types.js';
+import { DEFAULT_GRAPH_BASE_URL, DEFAULT_GRAPH_VERSION } from './graph-client.js';
+export { DEFAULT_GRAPH_BASE_URL, DEFAULT_GRAPH_VERSION };
+export interface CloudMe {
+    id: string;
+    name?: string;
+}
+export declare class CloudTransport implements Transport {
+    readonly ev: EventEmitter<[never]>;
+    readonly user: {
+        id: string;
+    };
+    private readonly options;
+    private readonly graph;
+    constructor(options: CloudOptions);
+    get apiVersion(): string;
+    get baseUrl(): string;
+    url(path: string): string;
+    /** Health check: token+phoneNumberId must resolve the phone-number node. No retry — a bad token never heals. */
+    connect(): Promise<CloudMe>;
+    disconnect(): Promise<void>;
+    /**
+     * Relay seam used by the builder for interactive sends (buttons/list/cta). Translates the
+     * proto to a Graph interactive payload. Returns the builder's messageId per contract, but
+     * the store records the real wamid via the upsert emit.
+     */
+    relayMessage: (jid: string, message: unknown, options: {
+        messageId: string;
+        additionalNodes?: unknown[];
+    }) => Promise<string>;
+    /** Post a raw interactive object to /messages; shared by flows/commerce/address sends. */
+    sendInteractive(to: string, interactive: Record<string, unknown>): Promise<WAMessage>;
+    /** Send an approved Meta message template (Cloud-only; templates are managed in Business Manager). */
+    sendTemplate(to: string, name: string, languageCode: string, components?: Array<Record<string, unknown>>): Promise<WAMessage>;
+    /** Mark an inbound message read; optionally show a typing indicator alongside. */
+    markRead(messageId: string, opts?: {
+        typing?: boolean;
+    }): Promise<void>;
+    /** Resolve a Meta media id to bytes: GET /{mediaId} -> short-lived CDN url -> authorized fetch. */
+    downloadMedia(mediaId: string): Promise<{
+        buffer: Buffer;
+        mime: string;
+        size: number;
+    } | null>;
+    /** Feed a verified webhook payload into the shared event pipeline. */
+    ingest(payload: unknown): void;
+    sendMessage(jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions): Promise<WAMessage | undefined>;
+}

package/dist/cloud/types.d.ts

@@ -0,0 +1,17 @@
+export interface CloudOptions {
+    /** Permanent or system-user access token for the WhatsApp Business app. */
+    accessToken: string;
+    /** Sender phone-number id (not the phone number itself). */
+    phoneNumberId: string;
+    /** WhatsApp Business Account id — optional, needed only for account-level ops. */
+    wabaId?: string;
+    /** Token echoed back on the webhook GET verification challenge. */
+    verifyToken?: string;
+    /** Meta app secret; enables X-Hub-Signature-256 verification of webhook POSTs. */
+    appSecret?: string;
+    /** Graph API version, e.g. 'v23.0'. Defaults to the pinned stable version. */
+    apiVersion?: string;
+    /** Override the Graph API origin (tests / proxies). */
+    baseUrl?: string;
+}
+export declare function validateCloudOptions(cloud: CloudOptions | undefined): CloudOptions;

package/dist/cloud/webhook.d.ts

@@ -0,0 +1,11 @@
+export type WebhookHandler = (req: Request) => Promise<Response>;
+export interface WebhookHandlerOptions {
+    verifyToken?: string;
+    appSecret?: string;
+    onPayload: (payload: unknown) => void;
+}
+/**
+ * Framework-agnostic Meta webhook endpoint: handles the GET verification challenge and
+ * signed POST deliveries. Mount it on any server that speaks Web Request/Response.
+ */
+export declare function createWebhookHandler(options: WebhookHandlerOptions): WebhookHandler;

package/dist/command/dispatcher.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from '../client/types.js';
+import type { MessageContext } from '../events/context.js';
+import type { CommandRegistry } from './registry.js';
+import type { CommandContext, Middleware } from './types.js';
+export interface ResolvedCommand {
+    command: string;
+    args: string[];
+    flags: Record<string, string | boolean>;
+    json: unknown;
+    raw: string;
+}
+export interface DispatcherDeps {
+    registry: CommandRegistry;
+    middleware: Middleware[];
+    prefixes: string[];
+    onText: (handler: (msg: MessageContext) => void) => () => void;
+    buildContext: (resolved: ResolvedCommand, msg: MessageContext) => CommandContext;
+    logger: Logger;
+}
+export interface DispatcherHandle {
+    detach(): void;
+}
+export declare function attachCommandDispatcher(deps: DispatcherDeps): DispatcherHandle;

package/dist/command/errors.d.ts

@@ -0,0 +1,8 @@
+export type CommandErrorCode = 'DUPLICATE_COMMAND' | 'INVALID_COMMAND_NAME' | 'HANDLER_ERROR' | 'MIDDLEWARE_ERROR' | 'NO_SENT_MESSAGE' | 'NOT_CONNECTED';
+export declare class ZaileysCommandError extends Error {
+    readonly code: CommandErrorCode;
+    readonly cause?: unknown;
+    constructor(code: CommandErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/command/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './errors.js';
+export { parseCommand } from './parser.js';
+export { CommandRegistry } from './registry.js';
+export { runMiddleware } from './middleware.js';
+export { attachCommandDispatcher } from './dispatcher.js';
+export type { DispatcherDeps, DispatcherHandle, ResolvedCommand } from './dispatcher.js';

package/dist/command/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext, Middleware } from './types.js';
+export declare function runMiddleware(chain: Middleware[], ctx: CommandContext, final: () => Promise<void> | void): Promise<void>;

package/dist/command/parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from './types.js';
+export declare function parseCommand(text: string, prefixes: string[]): ParsedArgs;

package/dist/command/registry.d.ts

@@ -0,0 +1,13 @@
+import type { CommandDefinition, CommandHandler, ParsedArgs } from './types.js';
+export declare class CommandRegistry {
+    private readonly paths;
+    private readonly defs;
+    private maxDepth;
+    register(spec: string, handler: CommandHandler): void;
+    resolve(parsed: ParsedArgs): {
+        def: CommandDefinition;
+        args: string[];
+    } | undefined;
+    unregister(spec: string): void;
+    list(): CommandDefinition[];
+}

package/dist/command/types.d.ts

@@ -0,0 +1,30 @@
+import type { WAMessageKey } from 'baileys';
+import type { MessageContext } from '../events/context.js';
+import type { TextOptions } from '../builder/builder.js';
+export type CommandPrefix = string | string[];
+export interface ParsedArgs {
+    matched: boolean;
+    name?: string;
+    args: string[];
+    flags: Record<string, string | boolean>;
+    json: unknown;
+    raw: string;
+}
+export interface CommandContext extends MessageContext {
+    raw: string;
+    command: string;
+    args: string[];
+    flags: Record<string, string | boolean>;
+    json: unknown;
+    reply(content: string, opts?: TextOptions): Promise<WAMessageKey>;
+    react(emoji: string): Promise<WAMessageKey>;
+    edit(content: string): Promise<void>;
+}
+export type CommandHandler = (ctx: CommandContext) => Promise<void> | void;
+export type Middleware = (ctx: CommandContext, next: () => Promise<void>) => Promise<void> | void;
+export interface CommandDefinition {
+    name: string;
+    aliases: string[];
+    parts: string[];
+    handler: CommandHandler;
+}

package/dist/connection/auth-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { SignalKeyStore } from 'baileys';
+import type { AuthStore } from '../auth/types.js';
+import type { Logger } from '../client/types.js';
+export declare function signalKeyStoreFromAuthStore(store: AuthStore, _logger?: Logger): SignalKeyStore;

package/dist/connection/auth-guard.d.ts

@@ -0,0 +1,37 @@
+import type { ConnectionAuthType } from '../client/types.js';
+/**
+ * Bounds QR and pairing-code regeneration across a client's lifetime to avoid
+ * tripping WhatsApp's spam/automation restriction. Each reconnect creates a fresh
+ * socket which re-emits a QR or requests a new pairing code; without a budget and
+ * cooldown this loops unbounded and gets the account restricted.
+ */
+export interface AuthGuardOptions {
+    /** Master switch. When `false` the guard never blocks (legacy behaviour). Default `true`. */
+    enabled?: boolean;
+    /** Total QR codes emitted before the guard stops and signals exhaustion. Default `5`. */
+    maxQrAttempts?: number;
+    /** Total pairing-code requests before the guard stops and signals exhaustion. Default `3`. */
+    maxPairingAttempts?: number;
+    /** Base cooldown between pairing-code requests; escalates per attempt. Default `60000`. */
+    pairingCooldownMs?: number;
+}
+export type AuthAttemptBlockReason = 'budget-exhausted' | 'cooldown';
+export interface AuthAttemptDecision {
+    allowed: boolean;
+    reason?: AuthAttemptBlockReason;
+    waitMs: number;
+    attempts: number;
+    max: number;
+}
+export interface AuthGuard {
+    /** Decide whether a new auth attempt of `kind` is permitted at time `now` (does not mutate). */
+    evaluate(kind: ConnectionAuthType, now: number): AuthAttemptDecision;
+    /** Record that an attempt of `kind` was actually issued at time `now`. */
+    record(kind: ConnectionAuthType, now: number): void;
+    /** Clear all counters and cooldowns (call on a successful connection or manual restart). */
+    reset(): void;
+    readonly enabled: boolean;
+    readonly qrAttempts: number;
+    readonly pairingAttempts: number;
+}
+export declare function createAuthGuard(options?: AuthGuardOptions): AuthGuard;

package/dist/connection/disconnect-reason.d.ts

@@ -0,0 +1,6 @@
+export type DisconnectReasonDomain = 'logged-out' | 'connection-replaced' | 'forbidden' | 'restart-required' | 'bad-session' | 'connection-closed' | 'connection-lost' | 'multi-device-mismatch' | 'unavailable-service' | 'rate-limited' | 'unknown';
+export declare function mapDisconnectReason(code: number | undefined): DisconnectReasonDomain;
+export declare function isFatalDisconnect(reason: DisconnectReasonDomain): boolean;
+export declare function isRateLimited(reason: DisconnectReasonDomain): boolean;
+export declare function shouldClearAuth(reason: DisconnectReasonDomain): boolean;
+export declare function shouldReconnect(reason: DisconnectReasonDomain): boolean;

package/dist/connection/index.d.ts

@@ -0,0 +1,7 @@
+export * from './auth-adapter.js';
+export * from './auth-guard.js';
+export * from './disconnect-reason.js';
+export * from './pairing-flow.js';
+export * from './qr-terminal.js';
+export * from './reconnect.js';
+export * from './state-machine.js';

package/dist/connection/pairing-flow.d.ts

@@ -0,0 +1,16 @@
+import type { BaileysSocket } from '../client/types.js';
+export interface PairingFlowOptions {
+    phoneNumber: string;
+    ttlMs?: number;
+}
+export interface PairingFlowResult {
+    code: string;
+    expiresAt: number;
+}
+export interface PairingFlow {
+    readonly phoneNumber: string;
+    requestCode(socket: Pick<BaileysSocket, 'requestPairingCode'>): Promise<PairingFlowResult>;
+}
+export declare function normalizePhoneNumber(raw: string): string;
+export declare function validateE164(raw: string): string;
+export declare function createPairingFlow(options: PairingFlowOptions): PairingFlow;

package/dist/connection/qr-terminal.d.ts

@@ -0,0 +1,2 @@
+export declare function renderQrInTerminal(qrString: string): Promise<string>;
+export declare function printQrToTerminal(qrString: string, write?: (s: string) => void): Promise<void>;

package/dist/connection/reconnect.d.ts

@@ -0,0 +1,15 @@
+import type { ReconnectOptions } from '../client/types.js';
+import { type DisconnectReasonDomain } from './disconnect-reason.js';
+export interface ReconnectDecision {
+    attempt: number;
+    delayMs: number;
+}
+export interface ReconnectStrategy {
+    next(reason: DisconnectReasonDomain): ReconnectDecision | null;
+    reset(): void;
+    readonly attempts: number;
+}
+export interface ReconnectStrategyDeps {
+    random?: () => number;
+}
+export declare function createReconnectStrategy(options?: ReconnectOptions, deps?: ReconnectStrategyDeps): ReconnectStrategy;

package/dist/connection/state-machine.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionState } from '../client/types.js';
+export type StateTransitionListener = (prev: ConnectionState, next: ConnectionState) => void;
+export interface ConnectionStateMachine {
+    readonly state: ConnectionState;
+    canTransition(next: ConnectionState): boolean;
+    transition(next: ConnectionState): void;
+    onChange(listener: StateTransitionListener): () => void;
+}
+export declare function createConnectionStateMachine(initial?: ConnectionState): ConnectionStateMachine;

package/dist/connection/status-log.d.ts

@@ -0,0 +1,25 @@
+import type { DisconnectReasonDomain } from './disconnect-reason.js';
+export type StatusEvent = {
+    kind: 'connecting';
+    sessionId: string;
+} | {
+    kind: 'qr';
+} | {
+    kind: 'pairing-code';
+    code: string;
+} | {
+    kind: 'connected';
+    id: string;
+} | {
+    kind: 'reconnecting';
+    attempt: number;
+    delayMs: number;
+    reason: DisconnectReasonDomain;
+    invalidCredsSuspected: boolean;
+} | {
+    kind: 'disconnect';
+    reason: DisconnectReasonDomain;
+    willReconnect: boolean;
+};
+export declare function formatConnectionStatus(event: StatusEvent): string | null;
+export declare function suppressLibsignalNoise(): void;

package/dist/domain/business.d.ts

@@ -0,0 +1,19 @@
+import type { DomainSocketLike } from './socket-like.js';
+export declare class BusinessModule {
+    private readonly getSocket;
+    constructor(getSocket: () => DomainSocketLike | undefined);
+    protected requireSocket(): DomainSocketLike;
+    profile(jid: string): Promise<unknown>;
+    catalog(opts?: {
+        jid?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    collections(jid?: string, limit?: number): Promise<unknown>;
+    orderDetails(orderId: string, tokenBase64: string): Promise<unknown>;
+    createProduct(create: Record<string, unknown>): Promise<unknown>;
+    updateProduct(productId: string, update: Record<string, unknown>): Promise<unknown>;
+    deleteProduct(...productIds: string[]): Promise<{
+        deleted: number;
+    }>;
+}