zaileys 4.7.0 → 4.7.2

package/dist/media/ffmpeg/audio.d.ts

@@ -0,0 +1,12 @@
+import { type MediaInput } from './core.js';
+export type AudioType = 'opus' | 'mp3';
+export declare class AudioProcessor {
+    static toOpus(input: MediaInput): Promise<Buffer>;
+    static toMp3(input: MediaInput): Promise<Buffer>;
+    static convert(input: MediaInput, type?: AudioType): Promise<Buffer>;
+    static waveform(input: MediaInput): Promise<{
+        waveform: Uint8Array;
+        seconds: number;
+    }>;
+    private static computeWaveform;
+}

package/dist/media/ffmpeg/core.d.ts

@@ -0,0 +1,67 @@
+export declare const FFMPEG_CONSTANTS: {
+    readonly OPUS: {
+        readonly CODEC: 'libopus';
+        readonly CHANNELS: 1;
+        readonly FREQUENCY: 48000;
+        readonly BITRATE: '48k';
+        readonly FORMAT: 'ogg';
+    };
+    readonly THUMBNAIL: {
+        readonly SIZE: 100;
+        readonly QUALITY: 50;
+        readonly TIMESTAMP: '10%';
+    };
+    readonly STICKER: {
+        readonly SIZE: 512;
+        readonly MAX_DURATION: 6;
+        readonly FPS: 10;
+        readonly DEFAULT_QUALITY: 60;
+        readonly COMPRESSION_LEVEL: 6;
+    };
+    readonly MIME: {
+        readonly AUDIO: 'audio/';
+        readonly VIDEO: 'video/';
+        readonly IMAGE: 'image/';
+        readonly GIF: 'image/gif';
+        readonly MP4: 'video/mp4';
+    };
+};
+export type MediaInput = string | ArrayBuffer | Buffer;
+export type FileExtension = 'wav' | 'ogg' | 'mp4' | 'gif' | 'jpg' | 'webp' | 'tmp' | 'mp3' | 'png';
+export interface FFmpegConfig {
+    input: string;
+    output: string;
+    options: string[];
+    onEnd: () => Promise<void>;
+    onError: (err: Error) => Promise<void>;
+}
+export declare const initializeFFmpeg: (disable?: boolean) => Promise<void>;
+export declare const generateId: () => string;
+export declare const detectFileType: (buffer: Buffer) => Promise<{
+    ext: string;
+    mime: string;
+} | undefined>;
+export declare class FileManager {
+    private static generateUniqueId;
+    static createTempPath(prefix: string, ext: FileExtension): string;
+    static cleanup(files: string[]): Promise<void>;
+    static safeReadFile(filePath: string): Promise<Buffer>;
+    static safeWriteFile(filePath: string, data: Buffer): Promise<void>;
+}
+export declare class BufferConverter {
+    static toBuffer(input: MediaInput): Promise<Buffer>;
+    private static fromString;
+    private static fromUrl;
+    static getExtension(buffer: Buffer): Promise<FileExtension>;
+}
+export declare class MimeValidator {
+    static validate(fileType: {
+        mime: string;
+    } | undefined, expectedPrefix: string): void;
+    static isMedia(mime: string): boolean;
+    static isAnimated(mime: string): boolean;
+}
+export declare class FFmpegProcessor {
+    static process(config: FFmpegConfig): Promise<void>;
+    static getDuration(filePath: string): Promise<number>;
+}

package/dist/media/ffmpeg/document.d.ts

@@ -0,0 +1,10 @@
+import { type MediaInput } from './core.js';
+export declare class DocumentProcessor {
+    static create(input: MediaInput): Promise<{
+        document: Buffer<ArrayBufferLike>;
+        mimetype: string;
+        ext: string;
+        fileName: string;
+        jpegThumbnail: string;
+    }>;
+}

package/dist/media/ffmpeg/image.d.ts

@@ -0,0 +1,7 @@
+import { type MediaInput } from './core.js';
+export declare class ImageProcessor {
+    static thumbnail(buffer: Buffer): Promise<string>;
+    static resize(buffer: Buffer, width: number, height: number): Promise<Buffer>;
+    static toJpeg(input: MediaInput): Promise<Buffer>;
+    static resizeForSticker(buffer: Buffer, quality: number, shape?: string): Promise<Buffer>;
+}

package/dist/media/ffmpeg/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core.js';
+export * from './transform.js';
+export * from './audio.js';
+export * from './video.js';
+export * from './image.js';
+export * from './sticker.js';
+export * from './document.js';

package/dist/media/ffmpeg/sticker.d.ts

@@ -0,0 +1,14 @@
+import { type MediaInput } from './core.js';
+export type StickerShapeType = 'circle' | 'rounded' | 'oval' | 'default';
+export interface StickerMetadataType {
+    packageName?: string;
+    authorName?: string;
+    quality?: number;
+    shape?: StickerShapeType;
+}
+export declare class StickerProcessor {
+    static create(input: MediaInput, metadata?: StickerMetadataType): Promise<Buffer>;
+    private static createExifMetadata;
+    private static processAnimated;
+    private static getExtension;
+}

package/dist/media/ffmpeg/transform.d.ts

@@ -0,0 +1,2 @@
+import { type FileExtension } from './core.js';
+export declare const ffmpegTransform: (buffer: Buffer, inExt: FileExtension, outExt: FileExtension, label: string, options: string[] | ((tempIn: string) => string[] | Promise<string[]>)) => Promise<Buffer>;

package/dist/media/ffmpeg/video.d.ts

@@ -0,0 +1,6 @@
+import { type MediaInput } from './core.js';
+export declare class VideoProcessor {
+    static toMp4(input: MediaInput): Promise<Buffer>;
+    static thumbnail(input: MediaInput): Promise<string>;
+    static duration(filePath: string): Promise<number>;
+}

package/dist/media/index.d.ts

@@ -0,0 +1,2 @@
+export * from './media.js';
+export * from './ffmpeg/index.js';

package/dist/media/media.d.ts

@@ -0,0 +1,39 @@
+import { type AudioType, type MediaInput, type StickerMetadataType } from './ffmpeg/index.js';
+export declare class Media {
+    private input;
+    constructor(input: MediaInput);
+    get audio(): {
+        toOpus: () => Promise<Buffer<ArrayBufferLike>>;
+        toMp3: () => Promise<Buffer<ArrayBufferLike>>;
+        convert: (type?: AudioType) => Promise<Buffer<ArrayBufferLike>>;
+        waveform: () => Promise<{
+            waveform: Uint8Array;
+            seconds: number;
+        }>;
+    };
+    get video(): {
+        toMp4: () => Promise<Buffer<ArrayBufferLike>>;
+        thumbnail: () => Promise<string>;
+    };
+    get image(): {
+        toJpeg: () => Promise<Buffer<ArrayBufferLike>>;
+        thumbnail: () => Promise<string>;
+        resize: (width: number, height: number) => Promise<Buffer<ArrayBufferLike>>;
+    };
+    get sticker(): {
+        create: (metadata?: StickerMetadataType) => Promise<Buffer<ArrayBufferLike>>;
+    };
+    get document(): {
+        create: () => Promise<{
+            document: Buffer<ArrayBufferLike>;
+            mimetype: string;
+            ext: string;
+            fileName: string;
+            jpegThumbnail: string;
+        }>;
+    };
+    get thumbnail(): {
+        get: () => Promise<string>;
+    };
+    toBuffer(): Promise<Buffer>;
+}

package/dist/plugin/index.d.ts

@@ -0,0 +1,5 @@
+export { definePlugin } from './types.js';
+export type { Plugin, PluginContext, PluginsOptions } from './types.js';
+export { PluginRegistry } from './registry.js';
+export type { PluginHost } from './registry.js';
+export { PluginLoader, scanPluginFiles, importPlugin } from './loader.js';

package/dist/plugin/loader.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from '../client/types.js';
+import type { PluginRegistry } from './registry.js';
+import type { Plugin, PluginsOptions } from './types.js';
+export declare function scanPluginFiles(dir: string, pattern: RegExp, ignore: RegExp): Promise<string[]>;
+export declare function importPlugin(file: string, bust?: number): Promise<Plugin | undefined>;
+export declare class PluginLoader {
+    private readonly dir;
+    private readonly pattern;
+    private readonly ignore;
+    private readonly watchEnabled;
+    private readonly onError;
+    private readonly registry;
+    private readonly logger;
+    private watcher;
+    private readonly fileToName;
+    private bust;
+    private debounce;
+    private readonly pending;
+    private flushChain;
+    constructor(deps: {
+        registry: PluginRegistry;
+        options: PluginsOptions;
+        logger?: Logger;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private loadFile;
+    private startWatch;
+    private flush;
+}

package/dist/plugin/registry.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '../client/types.js';
+import type { Plugin, PluginContext } from './types.js';
+export interface PluginHost {
+    command(spec: string, handler: Parameters<PluginContext['command']>[1]): unknown;
+    unregisterCommand(spec: string): void;
+    use(mw: Parameters<PluginContext['use']>[0]): unknown;
+    unuse(mw: Parameters<PluginContext['use']>[0]): unknown;
+    on: PluginContext['on'];
+    logger?: Logger | undefined;
+}
+export declare class PluginRegistry {
+    private readonly host;
+    private readonly logger;
+    private readonly plugins;
+    constructor(deps: {
+        client: PluginHost;
+        logger?: Logger;
+    });
+    has(name: string): boolean;
+    list(): string[];
+    loadPlugin(plugin: Plugin, file: string): Promise<void>;
+    unload(name: string): Promise<void>;
+    unloadAll(): Promise<void>;
+}

package/dist/plugin/types.d.ts

@@ -0,0 +1,25 @@
+import type { Client } from '../client/client.js';
+import type { Logger, ClientEventMap } from '../client/types.js';
+import type { CommandHandler, Middleware } from '../command/index.js';
+export interface PluginContext {
+    client: Client;
+    logger: Logger | undefined;
+    pluginDir: string;
+    command(spec: string, handler: CommandHandler): void;
+    use(middleware: Middleware): void;
+    on<E extends keyof ClientEventMap>(event: E, handler: (payload: ClientEventMap[E]) => void): () => void;
+    once<E extends keyof ClientEventMap>(event: E, handler: (payload: ClientEventMap[E]) => void): () => void;
+}
+export interface Plugin {
+    name: string;
+    setup(ctx: PluginContext): void | (() => void) | Promise<void | (() => void)>;
+    onUnload?(): void | Promise<void>;
+}
+export type PluginsOptions = {
+    dir?: string;
+    watch?: boolean;
+    pattern?: RegExp;
+    ignore?: RegExp;
+    onError?: (err: unknown, file: string) => void;
+};
+export declare const definePlugin: (plugin: Plugin) => Plugin;

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

@@ -0,0 +1,33 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+import { type ConvexKvOptions } from '../../types/convex.js';
+import type { BaileysSocketLike, MessageStore, MessageStoreListOptions, PruneOptions, ScheduledJobRecord } from '../types.js';
+export type ConvexMessageStoreOptions = ConvexKvOptions;
+export declare class ConvexMessageStore implements MessageStore {
+    private readonly kv;
+    private closed;
+    private boundSocket;
+    private readonly listeners;
+    constructor(options: ConvexMessageStoreOptions);
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    saveScheduledJob(job: ScheduledJobRecord): Promise<void>;
+    listScheduledJobs(): Promise<ScheduledJobRecord[]>;
+    deleteScheduledJob(id: string): Promise<void>;
+    deleteMessage(key: WAMessageKey): Promise<void>;
+    pruneMessages(opts: PruneOptions): Promise<number>;
+    bind(socket: BaileysSocketLike): void;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    private assertOpen;
+}

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

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

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

@@ -0,0 +1,31 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+import type { BaileysSocketLike, MessageStore, MessageStoreListOptions, PruneOptions } from '../types.js';
+export declare class MemoryMessageStore implements MessageStore {
+    private readonly messages;
+    private readonly messagesByJid;
+    private readonly chats;
+    private readonly contacts;
+    private readonly presence;
+    private boundSocket;
+    private readonly listeners;
+    private closed;
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    bind(socket: BaileysSocketLike): void;
+    deleteMessage(key: WAMessageKey): Promise<void>;
+    pruneMessages(opts: PruneOptions): Promise<number>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    private assertOpen;
+}

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

@@ -0,0 +1,40 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+import type { PgPoolLike } from '../../types/optional-clients.js';
+import type { BaileysSocketLike, MessageStore, MessageStoreListOptions, PruneOptions } from '../types.js';
+export interface PostgresMessageStoreOptions {
+    pool?: PgPoolLike;
+    connectionString?: string;
+    max?: number;
+}
+export declare class PostgresMessageStore implements MessageStore {
+    private readonly externalPool;
+    private readonly connectionString;
+    private readonly poolMax;
+    private ownedPool;
+    private resolvedPool;
+    private readyPromise;
+    private boundSocket;
+    private readonly listeners;
+    private closed;
+    constructor(options: PostgresMessageStoreOptions);
+    private assertOpen;
+    private ensureReady;
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    deleteMessage(key: WAMessageKey): Promise<void>;
+    pruneMessages(opts: PruneOptions): Promise<number>;
+    bind(socket: BaileysSocketLike): void;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+import type { RedisClientLike } from '../../types/optional-clients.js';
+import type { BaileysSocketLike, MessageStore, MessageStoreListOptions, PruneOptions } from '../types.js';
+export interface RedisMessageStoreOptions {
+    client?: RedisClientLike;
+    url?: string;
+    namespace?: string;
+}
+export declare class RedisMessageStore implements MessageStore {
+    private readonly namespace;
+    private readonly externalClient;
+    private readonly url;
+    private ownedClient;
+    private ready;
+    private closed;
+    private boundSocket;
+    private readonly listeners;
+    constructor(options: RedisMessageStoreOptions);
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    bind(socket: BaileysSocketLike): void;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    deleteMessage(key: WAMessageKey): Promise<void>;
+    pruneMessages(opts: PruneOptions): Promise<number>;
+    private jidFromIndexKey;
+    private msgIndexKey;
+    private msgDataKey;
+    private chatsKey;
+    private chatsArchiveKey;
+    private contactsKey;
+    private presenceKey;
+    private ensureReady;
+    private connect;
+    private runRead;
+    private runWrite;
+    private assertOpen;
+}

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

@@ -0,0 +1,36 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+import type { BaileysSocketLike, MessageStore, MessageStoreListOptions, PruneOptions } from '../types.js';
+export interface SqliteMessageStoreOptions {
+    database: string | Buffer;
+    readonly?: boolean;
+}
+export declare class SqliteMessageStore implements MessageStore {
+    private readonly options;
+    private db;
+    private prepared;
+    private readyPromise;
+    private closed;
+    private boundSocket;
+    private readonly listeners;
+    constructor(options: SqliteMessageStoreOptions);
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    deleteMessage(key: WAMessageKey): Promise<void>;
+    pruneMessages(opts: PruneOptions): Promise<number>;
+    bind(socket: BaileysSocketLike): void;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    private ensureReady;
+    private openAndMigrate;
+}

package/dist/store/index.d.ts

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

package/dist/store/types.d.ts

@@ -0,0 +1,48 @@
+import type { Chat, Contact, PresenceData, WAMessage, WAMessageKey } from 'baileys';
+export type MessageStoreListOptions = {
+    limit?: number;
+    before?: number;
+};
+export type PruneOptions = {
+    /** Delete messages whose `messageTimestamp` is strictly older than this epoch value, in **seconds** (matching stored `messageTimestamp`). */
+    olderThan?: number;
+    /** Keep only the newest N messages per chat. */
+    maxPerChat?: number;
+    /** Restrict pruning to chats whose jid passes this predicate. */
+    chatFilter?: (jid: string) => boolean;
+};
+export type ScheduledJobRecord = {
+    id: string;
+    fireAt: number;
+    recipient: string;
+    payload: unknown;
+};
+export interface BaileysSocketLike {
+    ev: {
+        on: (event: string, handler: (...args: unknown[]) => void) => void;
+        off?: (event: string, handler: (...args: unknown[]) => void) => void;
+    };
+}
+export interface MessageStore {
+    saveMessage(message: WAMessage): Promise<void>;
+    getMessage(key: WAMessageKey): Promise<WAMessage | undefined>;
+    listMessages(jid: string, options?: MessageStoreListOptions): Promise<WAMessage[]>;
+    saveChat(chat: Chat): Promise<void>;
+    getChat(jid: string): Promise<Chat | undefined>;
+    listChats(options?: {
+        archived?: boolean;
+    }): Promise<Chat[]>;
+    saveContact(contact: Contact): Promise<void>;
+    getContact(jid: string): Promise<Contact | undefined>;
+    listContacts(): Promise<Contact[]>;
+    savePresence(jid: string, presence: PresenceData): Promise<void>;
+    getPresence(jid: string): Promise<PresenceData | undefined>;
+    bind(socket: BaileysSocketLike): void;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    saveScheduledJob?(job: ScheduledJobRecord): Promise<void>;
+    listScheduledJobs?(): Promise<ScheduledJobRecord[]>;
+    deleteScheduledJob?(id: string): Promise<void>;
+    deleteMessage?(key: WAMessageKey): Promise<void>;
+    pruneMessages?(opts: PruneOptions): Promise<number>;
+}

package/dist/types/convex.d.ts

@@ -0,0 +1,35 @@
+export interface ConvexClientLike {
+    query(name: string, args: Record<string, unknown>): Promise<unknown>;
+    mutation(name: string, args: Record<string, unknown>): Promise<unknown>;
+}
+export interface ConvexKvOptions {
+    client?: ConvexClientLike;
+    url?: string;
+    namespace?: string;
+}
+export type ConvexKvRow = {
+    key: string;
+    value: string;
+    sortKey?: number;
+};
+export declare class ConvexKv {
+    readonly namespace: string;
+    private readonly externalClient;
+    private readonly url;
+    private client;
+    private closed;
+    constructor(options: ConvexKvOptions);
+    get(keys: readonly string[]): Promise<Map<string, string>>;
+    set(items: readonly ConvexKvRow[]): Promise<void>;
+    del(keys: readonly string[]): Promise<void>;
+    clear(prefix?: string): Promise<void>;
+    list(prefix: string, options?: {
+        before?: number;
+        limit?: number;
+    }): Promise<ConvexKvRow[]>;
+    close(): void;
+    private ensureClient;
+    private runRead;
+    private runWrite;
+    private assertOpen;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lid-mapping.js';
+export * from './store-error.js';
+export * from '../builder/index.js';
+export type { WAMessage, WAMessageKey, WAMessageContent, AnyMessageContent } from 'baileys';

package/dist/types/lid-mapping.d.ts

@@ -0,0 +1,5 @@
+export interface LIDMapping {
+    readonly lid: string;
+    readonly pn: string;
+}
+export type LIDMappingUpdatePayload = LIDMapping;

package/dist/types/optional-clients.d.ts

@@ -0,0 +1,69 @@
+/** Structural stand-ins for optional peers (pg, redis) so their types never leak into dist typings. */
+export interface PgQueryResultLike<R = Record<string, unknown>> {
+    rows: R[];
+    rowCount?: number | null;
+}
+export interface PgPoolClientLike {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<PgQueryResultLike<R>>;
+    release(): void;
+}
+export interface PgPoolLike {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<PgQueryResultLike<R>>;
+    connect(): Promise<PgPoolClientLike>;
+    end(): Promise<void>;
+}
+export interface PgPoolCtorLike {
+    new (config: {
+        connectionString?: string | undefined;
+        max?: number | undefined;
+    }): PgPoolLike;
+}
+export interface RedisMultiLike {
+    set(key: string, value: string): RedisMultiLike;
+    del(key: string): RedisMultiLike;
+    sAdd(key: string, members: string): RedisMultiLike;
+    sRem(key: string, members: string): RedisMultiLike;
+    hSet(key: string, field: string, value: string): RedisMultiLike;
+    hDel(key: string, fields: string | string[]): RedisMultiLike;
+    zAdd(key: string, entry: {
+        score: number;
+        value: string;
+    }): RedisMultiLike;
+    zRem(key: string, members: string | string[]): RedisMultiLike;
+    exec(): Promise<unknown>;
+}
+export interface RedisClientLike {
+    readonly isOpen: boolean;
+    connect(): Promise<unknown>;
+    quit(): Promise<unknown>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<unknown>;
+    del(keys: string | string[]): Promise<number>;
+    mGet(keys: string[]): Promise<Array<string | null>>;
+    hGet(key: string, field: string): Promise<string | null | undefined>;
+    hSet(key: string, field: string, value: string): Promise<number>;
+    hDel(key: string, fields: string | string[]): Promise<number>;
+    hmGet(key: string, fields: string[]): Promise<Array<string | null>>;
+    hGetAll(key: string): Promise<Record<string, string>>;
+    sAdd(key: string, members: string): Promise<number>;
+    sRem(key: string, members: string): Promise<number>;
+    sMembers(key: string): Promise<string[]>;
+    sIsMember(key: string, member: string): Promise<boolean | number>;
+    zRange(key: string, min: number, max: number): Promise<string[]>;
+    zRangeByScore(key: string, min: string | number, max: string | number, options?: {
+        LIMIT?: {
+            offset: number;
+            count: number;
+        };
+    }): Promise<string[]>;
+    scan(cursor: number, options?: {
+        MATCH?: string;
+        COUNT?: number;
+    }): Promise<{
+        cursor: number | string;
+        keys: string[];
+    }>;
+    multi(): RedisMultiLike;
+}

package/dist/types/store-error.d.ts

@@ -0,0 +1,8 @@
+export type StoreErrorCode = 'STORE_NOT_AVAILABLE' | 'STORE_CONNECTION_FAILED' | 'STORE_WRITE_FAILED' | 'STORE_READ_FAILED' | 'STORE_CORRUPTED' | 'STORE_CLOSED';
+export declare class ZaileysStoreError extends Error {
+    readonly code: StoreErrorCode;
+    readonly cause?: unknown;
+    constructor(code: StoreErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/utils/array.d.ts

@@ -0,0 +1 @@
+export declare const chunk: <T>(input: readonly T[], size: number) => T[][];