zaileys 4.7.1 → 4.7.2

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

@@ -0,0 +1,14 @@
+import { type AnyMessageContent } from 'baileys';
+import type { ListOptions } from '../types.js';
+export type ListContentRow = {
+    header: string;
+    title: string;
+    description: string;
+    id: string;
+};
+export type ListContentSection = {
+    title: string;
+    highlight_label: string;
+    rows: ListContentRow[];
+};
+export declare const buildListContent: (opts: ListOptions) => AnyMessageContent;

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

@@ -0,0 +1,11 @@
+import type { AnyMessageContent } from 'baileys';
+import type { LocationOptions } from '../types.js';
+export type LocationContent = {
+    location: {
+        degreesLatitude: number;
+        degreesLongitude: number;
+        name?: string;
+        address?: string;
+    };
+};
+export declare const buildLocationContent: (lat: number, lon: number, opts?: LocationOptions) => AnyMessageContent;

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

@@ -0,0 +1,2 @@
+import type { AIRichPart } from './airich.js';
+export declare const parseRichMarkdown: (md: string) => AIRichPart[];

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

@@ -0,0 +1,10 @@
+import type { AnyMessageContent } from 'baileys';
+import type { PollOptions } from '../types.js';
+export type PollContent = {
+    poll: {
+        name: string;
+        values: string[];
+        selectableCount: number;
+    };
+};
+export declare const buildPollContent: (question: string, options: string[], opts?: PollOptions) => AnyMessageContent;

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

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

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

@@ -0,0 +1,7 @@
+import type { AnyMessageContent } from 'baileys';
+import type { MediaSource, StickerOptions } from '../types.js';
+export type StickerContent = {
+    sticker: Buffer;
+    isAnimated?: boolean;
+};
+export declare const buildStickerContent: (src: MediaSource, opts?: StickerOptions) => Promise<AnyMessageContent>;

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

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

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

@@ -0,0 +1,4 @@
+export type TextContent = {
+    text: string;
+};
+export declare const buildTextContent: (text: string) => TextContent;

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

@@ -0,0 +1,10 @@
+import type { AnyMessageContent } from 'baileys';
+import type { MediaSource, VideoOptions } from '../types.js';
+export type VideoContent = {
+    video: Buffer;
+    caption?: string;
+    gifPlayback?: boolean;
+    viewOnce?: boolean;
+    ptv?: boolean;
+};
+export declare const buildVideoContent: (src: MediaSource, opts?: VideoOptions) => Promise<AnyMessageContent>;

package/dist/builder/edit-builder.d.ts

@@ -0,0 +1,15 @@
+import type { WAMessageKey } from 'baileys';
+import type { BuilderSocketLike } from './builder.js';
+import type { ImageOptions, MediaSource, VideoOptions } from './types.js';
+export declare class EditBuilder {
+    private readonly socket;
+    private readonly key;
+    private content;
+    private pendingContent;
+    constructor(socket: BuilderSocketLike, key: WAMessageKey);
+    text(content: string): this;
+    image(src: MediaSource, opts?: ImageOptions): this;
+    video(src: MediaSource, opts?: VideoOptions): this;
+    then<T = WAMessageKey>(onResolved: (key: WAMessageKey) => T, onRejected?: (err: unknown) => T | PromiseLike<T>): Promise<T>;
+    private send;
+}

package/dist/builder/errors.d.ts

@@ -0,0 +1,8 @@
+export type BuilderErrorCode = 'MEDIA_LOAD_FAILED' | 'INVALID_RECIPIENT' | 'USERNAME_NOT_FOUND' | 'EMPTY_CONTENT' | 'INVALID_OPTIONS' | 'SEND_FAILED' | 'MESSAGE_NOT_FOUND';
+export declare class ZaileysBuilderError extends Error {
+    readonly code: BuilderErrorCode;
+    readonly cause?: unknown;
+    constructor(code: BuilderErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/builder/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './errors.js';
+export { MessageBuilder, type BuilderSocketLike, type TextOptions } from './builder.js';
+export { EditBuilder } from './edit-builder.js';
+export { deleteMessage, reactToMessage, forwardMessage, pinMessage, type DeleteOptions, type PinOptions, } from './mutations.js';
+export { isJid, resolveUsername, type UsernameResolveSocketLike, } from './username-resolve.js';

package/dist/builder/media-loader.d.ts

@@ -0,0 +1,11 @@
+import type { MediaSource } from './types.js';
+export type LoadedMedia = {
+    buffer: Buffer;
+    mime: string;
+    size: number;
+};
+export type LoadMediaOptions = {
+    timeoutMs?: number;
+};
+export declare const detectMimeFromBuffer: (buffer: Buffer) => Promise<string>;
+export declare const loadMedia: (src: MediaSource, options?: LoadMediaOptions) => Promise<LoadedMedia>;

package/dist/builder/mutations.d.ts

@@ -0,0 +1,14 @@
+import type { WAMessageKey } from 'baileys';
+import type { MessageStore } from '../store/types.js';
+import type { BuilderSocketLike } from './builder.js';
+export type DeleteOptions = {
+    forEveryone?: boolean;
+};
+export type PinOptions = {
+    /** Pin duration in seconds (WhatsApp offers 86400 / 604800 / 2592000). Defaults to 24h. */
+    duration?: number;
+};
+export declare const deleteMessage: (socket: BuilderSocketLike, key: WAMessageKey, opts?: DeleteOptions) => Promise<void>;
+export declare const reactToMessage: (socket: BuilderSocketLike, key: WAMessageKey, emoji: string) => Promise<WAMessageKey>;
+export declare const forwardMessage: (socket: BuilderSocketLike, store: Pick<MessageStore, 'getMessage'>, key: WAMessageKey, to: string) => Promise<WAMessageKey>;
+export declare const pinMessage: (socket: BuilderSocketLike, key: WAMessageKey, pin: boolean, opts?: PinOptions) => Promise<WAMessageKey>;

package/dist/builder/state.d.ts

@@ -0,0 +1,15 @@
+import type { AnyMessageContent, WAMessage, WAMessageKey } from 'baileys';
+import type { AlbumItem } from './types.js';
+export type BuilderInternalState = {
+    recipient: string;
+    content?: AnyMessageContent;
+    pendingContent?: Promise<AnyMessageContent>;
+    albumItems?: AlbumItem[];
+    quoted?: WAMessage | WAMessageKey;
+    mentions?: string[];
+    mentionAll?: boolean;
+    disappearingSeconds?: number;
+    resolveRecipient?: (raw: string) => Promise<string>;
+    recordSent?: (message: WAMessage) => void;
+};
+export declare const createInternalState: (recipient: string, resolveRecipient?: (raw: string) => Promise<string>, recordSent?: (message: WAMessage) => void) => BuilderInternalState;

package/dist/builder/types.d.ts

@@ -0,0 +1,164 @@
+import type { WAMessage, WAMessageKey } from 'baileys';
+export type BuilderState = 'init' | 'content-set';
+export type MediaSource = string | Buffer | URL;
+export type ImageOptions = {
+    caption?: string;
+    viewOnce?: boolean;
+};
+export type VideoOptions = {
+    caption?: string;
+    gifPlayback?: boolean;
+    viewOnce?: boolean;
+    /** Send as a round video note (PTV). */
+    ptv?: boolean;
+};
+export type VideoNoteOptions = {
+    viewOnce?: boolean;
+};
+export type AudioOptions = {
+    ptt?: boolean;
+    seconds?: number;
+};
+export type DocumentOptions = {
+    fileName: string;
+    mimetype?: string;
+    caption?: string;
+};
+export type StickerOptions = {
+    animated?: boolean;
+};
+export type AlbumItem = {
+    type: 'image' | 'video';
+    src: MediaSource;
+    caption?: string;
+};
+export type ReplyButton = {
+    type?: 'reply';
+    id: string;
+    text: string;
+};
+export type UrlButton = {
+    type: 'url';
+    text: string;
+    url: string;
+    webview?: boolean;
+};
+export type CopyButton = {
+    type: 'copy';
+    text: string;
+    code: string;
+};
+export type CallButton = {
+    type: 'call';
+    text: string;
+    phone: string;
+};
+export type ReminderButton = {
+    type: 'reminder';
+    text: string;
+    id?: string;
+};
+export type CancelReminderButton = {
+    type: 'cancel-reminder';
+    text: string;
+    id?: string;
+};
+export type LocationRequestButton = {
+    type: 'location';
+    text?: string;
+};
+export type AddressButton = {
+    type: 'address';
+    text: string;
+    id?: string;
+};
+export type InteractiveButton = ReplyButton | UrlButton | CopyButton | CallButton | ReminderButton | CancelReminderButton | LocationRequestButton | AddressButton;
+export type BottomSheetOptions = {
+    listTitle?: string;
+    buttonTitle?: string;
+    buttonsLimit?: number;
+    dividers?: number[];
+};
+export type LimitedTimeOfferOptions = {
+    text?: string;
+    url?: string;
+    copyCode?: string;
+    expiresAt?: number;
+};
+export type ButtonDef = {
+    id: string;
+    text: string;
+};
+export type ListSection = {
+    title: string;
+    rows: Array<{
+        id: string;
+        title: string;
+        description?: string;
+    }>;
+};
+export type ListOptions = {
+    title?: string;
+    description?: string;
+    buttonText: string;
+    footerText?: string;
+    sections: ListSection[];
+};
+export type PollOptions = {
+    multipleChoice?: boolean;
+};
+export type LocationOptions = {
+    name?: string;
+    address?: string;
+};
+export type TemplateOptions = {
+    header?: string;
+    body: string;
+    footer?: string;
+    buttons: ButtonDef[];
+};
+export type EventOptions = {
+    name: string;
+    description?: string;
+    startAt: Date | number;
+    endAt?: Date | number;
+    location?: {
+        latitude: number;
+        longitude: number;
+        name?: string;
+        address?: string;
+    };
+    call?: 'audio' | 'video';
+    canceled?: boolean;
+};
+export type ProductOptions = {
+    image: MediaSource;
+    title: string;
+    businessOwnerId: string;
+    description?: string;
+    /** Price in currency units (e.g. 50 = 50.00); mapped to priceAmount1000. */
+    price?: number;
+    currency?: string;
+    productId?: string;
+    retailerId?: string;
+    url?: string;
+    body?: string;
+    footer?: string;
+};
+export type GroupInviteOptions = {
+    jid: string;
+    code: string;
+    subject?: string;
+    caption?: string;
+    /** Unix seconds when the invite expires. Defaults to ~3 days from now. WhatsApp reads this as seconds. */
+    expiresAt?: number;
+    /** Optional JPEG thumbnail (group avatar) — improves how the card renders. */
+    thumbnail?: Buffer;
+};
+export type BuilderContext = {
+    recipient: string;
+    quoted?: WAMessage | WAMessageKey;
+    mentions?: string[];
+    mentionAll?: boolean;
+    disappearingSeconds?: number;
+};

package/dist/builder/username-resolve.d.ts

@@ -0,0 +1,8 @@
+export interface UsernameResolveSocketLike {
+    onWhatsApp(...phoneNumber: string[]): Promise<Array<{
+        jid: string;
+        exists: boolean;
+    }> | undefined>;
+}
+export declare const isJid: (value: string) => boolean;
+export declare const resolveUsername: (socket: UsernameResolveSocketLike, username: string, cache: Map<string, string>, inflight?: Map<string, Promise<string>>) => Promise<string>;

package/dist/client/client.d.ts

@@ -0,0 +1,130 @@
+import { type WAMessageKey } from 'baileys';
+import { EditBuilder, MessageBuilder, type DeleteOptions, type PinOptions } from '../builder/index.js';
+import { CommunityModule, GroupModule, BusinessModule, ChatModule, ContactModule, NewsletterModule, PrivacyModule, ProfileModule } from '../domain/index.js';
+import { type CommandHandler, type Middleware } from '../command/index.js';
+import { PresenceModule, type BroadcastOptions, type BroadcastResult, type ScheduleHandle } from '../automation/index.js';
+import type { MediaDownloadResult } from '../events/types.js';
+import type { AuthStoreBundle } from '../auth/types.js';
+import type { MessageStore } from '../store/types.js';
+import { TypedEventEmitter } from './event-emitter.js';
+import type { BaileysSocket, ClientEventMap, ClientOptions, ConnectionState } from './types.js';
+export declare class Client extends TypedEventEmitter<ClientEventMap> {
+    readonly sessionId: string;
+    auth: AuthStoreBundle;
+    readonly store: MessageStore;
+    private readonly logger;
+    private readonly authType;
+    private readonly phoneNumber;
+    private readonly cacheSignal;
+    private readonly qrTerminal;
+    private readonly statusLog;
+    private readonly reconnectOptions;
+    private readonly baileysExtra;
+    private readonly machine;
+    private reconnectStrategy;
+    private readonly authGuard;
+    private readonly operationGuard;
+    private readonly presenceThrottle;
+    private readonly scheduleLimiter;
+    private authExhausted;
+    private _socket;
+    private reconnectTimer;
+    private listenerCleanup;
+    private inboundHandle;
+    private connectResolve;
+    private connectReject;
+    private pairingRequested;
+    private cachedSignalWrap;
+    private creds;
+    private credsLoadedAtConnect;
+    private openedThisRun;
+    private credsHintShown;
+    private postOpenLogoutRetries;
+    private disconnectEmittedFor;
+    private connectAttemptSeq;
+    private pendingDisconnectReason;
+    private readonly usernameCache;
+    private _group?;
+    private _privacy?;
+    private _newsletter?;
+    private _community?;
+    private _profile?;
+    private _chat?;
+    private _contact?;
+    private _business?;
+    private commandRegistry?;
+    private readonly commandMiddleware;
+    private readonly commandPrefixes;
+    private readonly citationConfig;
+    private readonly ignoreMe;
+    private commandDispatcher;
+    private _presence?;
+    private _scheduler?;
+    private readonly autoDeleteOptions;
+    private autoDeleteSweeper;
+    private readonly pluginsOptions;
+    private pluginRegistry;
+    private pluginLoader;
+    private waVersion?;
+    private versionWarming?;
+    constructor(options?: ClientOptions);
+    private warmVersion;
+    private emitAutoConnectError;
+    private logStatus;
+    private resolveMe;
+    get state(): ConnectionState;
+    get socket(): BaileysSocket | undefined;
+    get group(): GroupModule;
+    get privacy(): PrivacyModule;
+    get newsletter(): NewsletterModule;
+    get community(): CommunityModule;
+    get profile(): ProfileModule;
+    get chat(): ChatModule;
+    get contact(): ContactModule;
+    get business(): BusinessModule;
+    get presence(): PresenceModule;
+    broadcast(jids: string[], build: (b: MessageBuilder<'init'>) => MessageBuilder<'content-set'>, options?: BroadcastOptions): Promise<BroadcastResult>;
+    scheduleAt(date: Date, build: (b: MessageBuilder<'init'>) => MessageBuilder<'content-set'>): Promise<ScheduleHandle>;
+    private ensureScheduler;
+    private dispatchSnapshot;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    logout(): Promise<void>;
+    command(spec: string, handler: CommandHandler): this;
+    unregisterCommand(spec: string): this;
+    use(middleware: Middleware): this;
+    unuse(middleware: Middleware): this;
+    private attachCommandsIfReady;
+    private buildCommandContext;
+    private detachCommands;
+    send(to: string): MessageBuilder<'init'>;
+    edit(key: WAMessageKey): EditBuilder;
+    delete(key: WAMessageKey, opts?: DeleteOptions): Promise<void>;
+    react(key: WAMessageKey, emoji: string): Promise<WAMessageKey>;
+    forward(key: WAMessageKey, to: string): Promise<WAMessageKey>;
+    pin(key: WAMessageKey, opts?: PinOptions): Promise<WAMessageKey>;
+    unpin(key: WAMessageKey): Promise<WAMessageKey>;
+    setDisappearing(to: string, seconds: number): Promise<void>;
+    private resolveRecipient;
+    private requireSocket;
+    private attachEmitterLogger;
+    private wireSocket;
+    private handleConnectionUpdate;
+    private handleQrUpdate;
+    private handleAuthExhausted;
+    private handleOpen;
+    private resolveMessageForResend;
+    private lidMapping;
+    /** Resolve a `@lid` JID to its phone-number JID (uses WhatsApp's LID mapping; may hit the network). */
+    lidToPn(lid: string): Promise<string | null>;
+    /** Resolve a phone-number JID to its `@lid` JID (uses WhatsApp's LID mapping; may hit the network). */
+    pnToLid(pn: string): Promise<string | null>;
+    /**
+     * Download media bytes for a message stored in the message store (by key).
+     * Tries both `fromMe` variants. `null` when the message is unknown or carries no media.
+     */
+    downloadMedia(key: WAMessageKey): Promise<MediaDownloadResult | null>;
+    private lookupQuoted;
+    private handleClose;
+    private rejectPendingConnect;
+}

package/dist/client/event-emitter.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from './types.js';
+export interface TypedEventEmitterOptions {
+    logger?: Logger | undefined;
+}
+export declare class TypedEventEmitter<M extends Record<string, unknown>> {
+    private readonly inner;
+    protected readonly emitterLogger: Logger | undefined;
+    constructor(options?: TypedEventEmitterOptions);
+    on<E extends keyof M>(event: E, handler: (payload: M[E]) => void): () => void;
+    off<E extends keyof M>(event: E, handler: (payload: M[E]) => void): void;
+    emit<E extends keyof M>(event: E, payload: M[E]): void;
+    removeAllListeners(event?: keyof M): void;
+    listenerCount(event: keyof M): number;
+    private wrap;
+    private tag;
+    private untag;
+    private lookup;
+    private tagMap;
+}

package/dist/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client.js';
+export * from './event-emitter.js';
+export * from './types.js';

package/dist/client/types.d.ts

@@ -0,0 +1,104 @@
+import type { UserFacingSocketConfig, WASocket } from 'baileys';
+import type { AuthStoreBundle } from '../auth/types.js';
+import type { AutoDeleteOptions } from '../automation/auto-delete.js';
+import type { OperationGuardOptions } from '../automation/operation-guard.js';
+import type { PresenceThrottleOptions } from '../automation/presence.js';
+import type { AuthGuardOptions } from '../connection/auth-guard.js';
+import type { DisconnectReasonDomain } from '../connection/disconnect-reason.js';
+import type { CitationConfig } from '../events/context.js';
+import type { InboundEventMap } from '../events/types.js';
+import type { MessageStore } from '../store/types.js';
+import type { PluginsOptions } from '../plugin/types.js';
+export type ConnectionState = 'idle' | 'connecting' | 'qr-pending' | 'pairing-pending' | 'connected' | 'reconnecting' | 'disconnecting' | 'disconnected';
+export type ConnectionAuthType = 'qr' | 'pairing';
+export interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    fatal(...args: unknown[]): void;
+}
+export interface ReconnectOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    jitterFactor?: number;
+    /** Fixed backoff applied when the disconnect reason is `rate-limited` (429). Default `300000`. */
+    rateLimitedDelayMs?: number;
+}
+export interface ClientOptions {
+    sessionId?: string;
+    auth?: AuthStoreBundle;
+    store?: MessageStore;
+    authType?: ConnectionAuthType;
+    phoneNumber?: string;
+    logger?: Logger;
+    cacheSignal?: boolean;
+    reconnect?: ReconnectOptions;
+    qrTerminal?: boolean;
+    baileys?: Partial<UserFacingSocketConfig>;
+    autoConnect?: boolean;
+    statusLog?: boolean;
+    commandPrefix?: string | string[];
+    citation?: CitationConfig;
+    ignoreMe?: boolean;
+    /** Bounds QR/pairing regeneration to avoid spam restriction. ON by default; `{ enabled: false }` to opt out. */
+    authGuard?: AuthGuardOptions;
+    /** Spaces out sensitive group/community/newsletter operations. ON by default; `{ enabled: false }` to opt out. */
+    operationGuard?: OperationGuardOptions;
+    /** Drops duplicate presence (typing/recording/online) updates within a window. ON by default. */
+    presence?: PresenceThrottleOptions;
+    /** Max scheduled messages dispatched per second, smoothing backlog bursts. Default `1`; `0` disables. */
+    scheduleRateLimitPerSec?: number;
+    /** Periodically prune old messages from the store. Enabled by default with a 1-month `maxAgeMs`; pass `false` to disable or override any field. */
+    autoDelete?: AutoDeleteOptions | false;
+    /** Load and manage plugins from a directory. */
+    plugins?: PluginsOptions;
+}
+export type ConnectionEventMap = {
+    connect: {
+        sessionId: string;
+        me: {
+            id: string;
+            lid?: string;
+            name?: string;
+        };
+    };
+    disconnect: {
+        sessionId: string;
+        reason: DisconnectReasonDomain;
+        willReconnect: boolean;
+    };
+    qr: {
+        sessionId: string;
+        qrString: string;
+        expiresAt: number;
+    };
+    'pairing-code': {
+        sessionId: string;
+        code: string;
+        expiresAt: number;
+    };
+    reconnecting: {
+        sessionId: string;
+        attempt: number;
+        delayMs: number;
+        reason: DisconnectReasonDomain;
+    };
+    'auth-exhausted': {
+        sessionId: string;
+        kind: ConnectionAuthType;
+        attempts: number;
+        max: number;
+    };
+    error: {
+        sessionId: string;
+        error: Error;
+    };
+};
+export type ConnectionEventName = keyof ConnectionEventMap;
+export type ConnectionEventHandler<E extends ConnectionEventName> = (payload: ConnectionEventMap[E]) => void;
+export type ClientEventMap = ConnectionEventMap & InboundEventMap;
+export type ClientEventName = keyof ClientEventMap;
+export type BaileysSocket = WASocket;

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[];
+}