ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/qldb/index.js

@@ -27,7 +27,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QldbStore = void 0;
 const errors_1 = require("../../errors");
 /** A validated PartiQL identifier - QLDB cannot parameterize table names. */
-const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_.]*$/;
 function assertIdentifier(name) {
     if (!IDENTIFIER.test(name)) {
         throw new errors_1.DatabaseError(`Invalid QLDB table name: ${JSON.stringify(name)}`, {
@@ -36,6 +36,171 @@ function assertIdentifier(name) {
     }
     return name;
 }
+/** Parse an ORM `where` object (string + `Op` symbol keys) into a tree. */
+function parseWhere(where) {
+    if (!where || typeof where !== 'object')
+        return null;
+    const nodes = [];
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const name = sym.description;
+        const val = where[sym];
+        if (name === 'and' && Array.isArray(val)) {
+            nodes.push({ kind: 'and', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'or' && Array.isArray(val)) {
+            nodes.push({ kind: 'or', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'not') {
+            const inner = parseWhere(val);
+            if (inner)
+                nodes.push({ kind: 'not', node: inner });
+        }
+    }
+    for (const field of Object.keys(where)) {
+        nodes.push(parseFieldCondition(field, where[field]));
+    }
+    const flat = nodes.filter(Boolean);
+    if (flat.length === 0)
+        return null;
+    return flat.length === 1 ? flat[0] : { kind: 'and', nodes: flat };
+}
+/** Parse the value for a single field into a comparison (or AND of them). */
+function parseFieldCondition(field, value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const symbols = Object.getOwnPropertySymbols(value);
+        if (symbols.length > 0) {
+            const cmps = symbols.map((sym) => ({
+                kind: 'cmp',
+                field,
+                op: sym.description ?? 'eq',
+                value: value[sym],
+            }));
+            return cmps.length === 1 ? cmps[0] : { kind: 'and', nodes: cmps };
+        }
+    }
+    return { kind: 'cmp', field, op: value === null ? 'isNull' : 'eq', value };
+}
+/** Render a normalized tree to a parameterized PartiQL predicate. */
+function compilePartiqlWhere(node) {
+    if (!node)
+        return { sql: '', params: [] };
+    const params = [];
+    const render = (n) => {
+        switch (n.kind) {
+            case 'and':
+                return n.nodes.length ? `(${n.nodes.map(render).join(' AND ')})` : 'true';
+            case 'or':
+                return n.nodes.length ? `(${n.nodes.map(render).join(' OR ')})` : 'false';
+            case 'not':
+                return `NOT (${render(n.node)})`;
+            case 'cmp':
+                return renderCmp(n.field, n.op, n.value, params);
+        }
+    };
+    return { sql: render(node), params };
+}
+function renderCmp(field, op, value, params) {
+    const col = assertIdentifier(field);
+    const p = (v) => {
+        params.push(v);
+        return '?';
+    };
+    switch (op) {
+        case 'eq':
+            return value === null ? `${col} IS NULL` : `${col} = ${p(value)}`;
+        case 'ne':
+            return value === null ? `${col} IS NOT NULL` : `${col} <> ${p(value)}`;
+        case 'gt':
+            return `${col} > ${p(value)}`;
+        case 'gte':
+            return `${col} >= ${p(value)}`;
+        case 'lt':
+            return `${col} < ${p(value)}`;
+        case 'lte':
+            return `${col} <= ${p(value)}`;
+        case 'in': {
+            const arr = value ?? [];
+            if (arr.length === 0)
+                return 'false';
+            return `${col} IN (${arr.map(p).join(', ')})`;
+        }
+        case 'notIn': {
+            const arr = value ?? [];
+            if (arr.length === 0)
+                return 'true';
+            return `${col} NOT IN (${arr.map(p).join(', ')})`;
+        }
+        case 'between': {
+            const [a, b] = value;
+            return `${col} BETWEEN ${p(a)} AND ${p(b)}`;
+        }
+        case 'notBetween': {
+            const [a, b] = value;
+            return `${col} NOT BETWEEN ${p(a)} AND ${p(b)}`;
+        }
+        case 'like':
+            return `${col} LIKE ${p(value)}`;
+        case 'notLike':
+            return `${col} NOT LIKE ${p(value)}`;
+        case 'startsWith':
+            return `${col} LIKE ${p(`${String(value)}%`)}`;
+        case 'endsWith':
+            return `${col} LIKE ${p(`%${String(value)}`)}`;
+        case 'substring':
+            return `${col} LIKE ${p(`%${String(value)}%`)}`;
+        case 'isNull':
+            return `${col} IS NULL`;
+        case 'isNotNull':
+            return `${col} IS NOT NULL`;
+        default:
+            throw new errors_1.DatabaseError(`QLDB ORM layer does not support operator "${op}" for field "${field}"`, { code: 'QUERY_ERROR' });
+    }
+}
+/**
+ * Pull the plain-equality (`field: value`) pairs out of a `where` clause so
+ * an upsert's INSERT branch can seed the new document with the keys it was
+ * matched on. Operator-keyed and logical (`Op.and`/`Op.or`) conditions are
+ * skipped since they don't correspond to a single concrete value.
+ */
+function extractEqualityKeys(where) {
+    const out = {};
+    for (const field of Object.keys(where)) {
+        const val = where[field];
+        if (val === null || typeof val !== 'object' || Array.isArray(val)) {
+            out[field] = val;
+        }
+    }
+    return out;
+}
+/** Apply ORM order/limit/offset to an already-fetched row list, client-side. */
+function applyClientSideShape(rows, options) {
+    let out = rows;
+    if (options.order && options.order.length > 0) {
+        const order = options.order;
+        out = [...out].sort((a, b) => {
+            for (const [field, dir] of order) {
+                const av = a?.[field];
+                const bv = b?.[field];
+                if (av === bv)
+                    continue;
+                const cmp = av === undefined || av === null
+                    ? -1
+                    : bv === undefined || bv === null
+                        ? 1
+                        : av < bv
+                            ? -1
+                            : 1;
+                return dir.toUpperCase() === 'DESC' ? -cmp : cmp;
+            }
+            return 0;
+        });
+    }
+    if (typeof options.offset === 'number')
+        out = out.slice(options.offset);
+    if (typeof options.limit === 'number')
+        out = out.slice(0, options.limit);
+    return out;
+}
 /**
  * `QldbStore` wraps an `amazon-qldb-driver-nodejs` driver behind the shared
  * ledger surface. `append` inserts a new document (returning its QLDB
@@ -171,6 +336,142 @@ class QldbStore {
     async query(statement, params = []) {
         return this.execute(statement, params, 'query');
     }
+    // ---------------------------------------------------------------------
+    // ORM model surface (no hand-written PartiQL needed)
+    // ---------------------------------------------------------------------
+    /**
+     * Fetch every document in `table` matching the ORM `where` clause. The
+     * `where` clause is compiled to a parameterized PartiQL `WHERE`; `order`,
+     * `limit` and `offset` are applied client-side because QLDB's PartiQL
+     * dialect supports none of them.
+     */
+    async findAll(table, options = {}) {
+        const tbl = assertIdentifier(table);
+        const { sql, params } = compilePartiqlWhere(parseWhere(options.where));
+        const projection = options.attributes && options.attributes.length > 0
+            ? options.attributes.map(assertIdentifier).join(', ')
+            : '*';
+        const statement = `SELECT ${projection} FROM ${tbl}${sql ? ` WHERE ${sql}` : ''}`;
+        const rows = (await this.execute(statement, params, 'findAll'));
+        return applyClientSideShape(rows, options);
+    }
+    /** Fetch the first document matching `where` (client-side `limit 1`), or `null`. */
+    async findOne(table, options = {}) {
+        const rows = await this.findAll(table, { ...options, limit: 1 });
+        return rows[0] ?? null;
+    }
+    /** Count documents in `table` matching `where`. */
+    async count(table, where) {
+        const rows = await this.findAll(table, { where });
+        return rows.length;
+    }
+    /**
+     * Insert `data` as a new document, returning its QLDB document id. Alias
+     * of {@link append} using ORM naming.
+     */
+    async create(table, data) {
+        return this.append(table, data);
+    }
+    /**
+     * Insert many documents in a single managed transaction, returning the new
+     * document ids in order.
+     */
+    async bulkCreate(table, rows) {
+        if (rows.length === 0)
+            return [];
+        const tbl = assertIdentifier(table);
+        return this.transaction(async (txn) => {
+            const ids = [];
+            for (const row of rows) {
+                const result = await txn.execute(`INSERT INTO ${tbl} ?`, row);
+                const first = result.getResultList()[0];
+                ids.push(first?.documentId ?? '');
+            }
+            return ids;
+        });
+    }
+    /**
+     * Update every document matching `where`, SETting each key in `values`.
+     * Returns the number of documents QLDB reported as modified.
+     */
+    async update(table, values, where) {
+        const tbl = assertIdentifier(table);
+        const entries = Object.entries(values);
+        if (entries.length === 0) {
+            throw new errors_1.DatabaseError('QLDB update() requires at least one value to set', {
+                code: 'VALIDATION_ERROR',
+            });
+        }
+        const setParams = [];
+        const setSql = entries
+            .map(([col, val]) => {
+            setParams.push(val);
+            return `${assertIdentifier(col)} = ?`;
+        })
+            .join(', ');
+        const { sql, params } = compilePartiqlWhere(parseWhere(where));
+        const statement = `UPDATE ${tbl} SET ${setSql}${sql ? ` WHERE ${sql}` : ''}`;
+        const rows = await this.execute(statement, [...setParams, ...params], 'update');
+        return rows.length;
+    }
+    /**
+     * Delete every document matching `where`. Returns the number of documents
+     * QLDB reported as deleted. QLDB retains all prior revisions in the
+     * journal, so a delete is itself a new (tombstone) revision - use
+     * {@link history} to recover deleted data.
+     */
+    async destroy(table, where) {
+        const tbl = assertIdentifier(table);
+        const { sql, params } = compilePartiqlWhere(parseWhere(where));
+        const statement = `DELETE FROM ${tbl}${sql ? ` WHERE ${sql}` : ''}`;
+        const rows = await this.execute(statement, params, 'destroy');
+        return rows.length;
+    }
+    /**
+     * Insert-or-update: within a single transaction, look for a document
+     * matching `where`; if one exists, SET `data` onto the matches, otherwise
+     * INSERT `data` (merged with the `where` equality keys). Returns
+     * `{ created }` indicating which branch ran.
+     */
+    async upsert(table, data, where) {
+        const tbl = assertIdentifier(table);
+        const { sql, params } = compilePartiqlWhere(parseWhere(where));
+        return this.transaction(async (txn) => {
+            const existing = sql
+                ? (await txn.execute(`SELECT * FROM ${tbl} WHERE ${sql}`, ...params)).getResultList()
+                : [];
+            if (existing.length > 0) {
+                const entries = Object.entries(data);
+                const setParams = [];
+                const setSql = entries
+                    .map(([col, val]) => {
+                    setParams.push(val);
+                    return `${assertIdentifier(col)} = ?`;
+                })
+                    .join(', ');
+                await txn.execute(`UPDATE ${tbl} SET ${setSql} WHERE ${sql}`, ...setParams, ...params);
+                return { created: false };
+            }
+            const insertDoc = { ...extractEqualityKeys(where), ...data };
+            await txn.execute(`INSERT INTO ${tbl} ?`, insertDoc);
+            return { created: true };
+        });
+    }
+    /**
+     * Run `fn` inside a single managed QLDB transaction (auto-retried on
+     * optimistic-concurrency conflicts). The callback receives the raw
+     * transaction executor so it can compose several statements atomically.
+     */
+    async transaction(fn) {
+        const driver = this.requireDriver();
+        try {
+            return await driver.executeLambda(fn);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `QLDB transaction failed: ${parent.message}` });
+        }
+    }
     /** List the active table names in the ledger (thin passthrough). */
     async tableNames() {
         const driver = this.requireDriver();

package/dist/nosql/r2/index.d.ts

@@ -0,0 +1,160 @@
+import type { NoSqlStore } from '../store';
+/**
+ * A loosely-typed handle to an AWS v3 `S3Client` (or any object exposing a
+ * compatible `send(command)` method). Kept as an interface rather than the
+ * real SDK type because `@aws-sdk/client-s3` is loaded lazily and may not be
+ * installed at type-check time; tests inject a mock matching this shape.
+ */
+export interface R2ClientLike {
+    send(command: unknown): Promise<any>;
+    destroy?(): void;
+}
+/** Connection options for `R2Store`. */
+export interface R2StoreOptions {
+    /**
+     * The account-specific R2 S3 endpoint, e.g.
+     * `https://<account_id>.r2.cloudflarestorage.com`. Required unless a
+     * pre-built `client` is supplied.
+     */
+    endpoint?: string;
+    /**
+     * R2 access-key credentials (created in the Cloudflare dashboard as an "R2
+     * API Token"). Omit only when supplying a pre-built `client`.
+     */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /**
+     * Region to advertise to the SDK. R2 has no regions and expects the
+     * sentinel value `'auto'`; this defaults to `'auto'` and rarely needs
+     * changing.
+     */
+    region?: string;
+    /**
+     * A pre-built `S3Client` (or compatible object). When provided,
+     * `connect()` uses it directly and does NOT require the SDK — this is how
+     * tests inject a mock client, and how callers can supply a custom-configured
+     * client. When omitted, `connect()` builds a real `S3Client` pointed at R2
+     * from the options above.
+     */
+    client?: R2ClientLike;
+}
+/** Options for `putObject()`. */
+export interface PutObjectOptions {
+    /** MIME type of the body, e.g. 'application/json'. */
+    contentType?: string;
+    /** Arbitrary user metadata (stored as `x-amz-meta-*` headers). */
+    metadata?: Record<string, string>;
+    /** Cache-Control header value to store with the object. */
+    cacheControl?: string;
+    /** Content-Encoding header value to store with the object. */
+    contentEncoding?: string;
+}
+/** Result of `putObject()`. */
+export interface PutObjectResult {
+    /** Entity tag of the newly stored object. */
+    etag?: string;
+    /** Version ID, when the bucket has versioning enabled. */
+    versionId?: string;
+}
+/** Result of `getObject()`. */
+export interface GetObjectResult {
+    /** The object's body stream/blob, exactly as the SDK returns it. */
+    body: unknown;
+    contentType?: string;
+    contentLength?: number;
+    etag?: string;
+    lastModified?: Date;
+    metadata?: Record<string, string>;
+}
+/** Result of `headObject()` — object metadata without the body. */
+export interface HeadObjectResult {
+    contentType?: string;
+    contentLength?: number;
+    etag?: string;
+    lastModified?: Date;
+    metadata?: Record<string, string>;
+}
+/** A single object entry in a `listObjects()` result. */
+export interface R2ObjectSummary {
+    key?: string;
+    size?: number;
+    etag?: string;
+    lastModified?: Date;
+}
+/** Result of `listObjects()`. */
+export interface ListObjectsResult {
+    objects: R2ObjectSummary[];
+    /** True when the listing was truncated (more objects exist than were returned). */
+    isTruncated: boolean;
+    /** Continuation token to fetch the next page, present when `isTruncated`. */
+    nextContinuationToken?: string;
+}
+/**
+ * Cloudflare R2 store, implementing the minimal `NoSqlStore` marker interface.
+ * Unlike the SQL dialects there is no `query(sql)` — R2's operations are
+ * object-shaped (Put/Get/Delete/List/Head) and that shape is preserved here
+ * rather than forced into a SQL string.
+ */
+export declare class R2Store implements NoSqlStore {
+    readonly name = "r2";
+    readonly library = "@aws-sdk/client-s3";
+    private readonly options;
+    private client;
+    private aws;
+    private connected;
+    constructor(options?: R2StoreOptions);
+    connect(): Promise<void>;
+    /**
+     * Attempt to lazy-load `@aws-sdk/client-s3` for its command constructors.
+     * Best-effort: when a client was injected (e.g. a test mock) the SDK may
+     * not be installed, so a failure here is swallowed and the command classes
+     * are loaded on demand instead (see `command()`).
+     */
+    private tryLoadSdk;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `S3Client` (loosely typed) for anything not wrapped here. */
+    getClient(): R2ClientLike;
+    private requireClient;
+    /**
+     * Resolve an S3 command constructor by name from the (lazily loaded) SDK,
+     * so that with an injected mock client we only load `@aws-sdk/client-s3`
+     * the first time a command is actually built. Throws a `ConnectionError`
+     * if the SDK genuinely can't be resolved.
+     */
+    private command;
+    /** Wraps an AWS SDK failure in a `DatabaseError`, preserving the original error. */
+    private wrapError;
+    /** `PutObject` — store an object's body (and optional metadata) under `bucket`/`key`. */
+    putObject(bucket: string, key: string, body: unknown, options?: PutObjectOptions): Promise<PutObjectResult>;
+    /** `GetObject` — fetch an object's body and metadata. */
+    getObject(bucket: string, key: string): Promise<GetObjectResult>;
+    /** `DeleteObject` — remove an object. Succeeds even if the key doesn't exist. */
+    deleteObject(bucket: string, key: string): Promise<void>;
+    /**
+     * `ListObjectsV2` — list objects in `bucket`, optionally restricted to
+     * those whose key starts with `prefix`. A single call returns at most
+     * 1000 objects; use `result.nextContinuationToken` (via the raw client)
+     * to page beyond that.
+     */
+    listObjects(bucket: string, prefix?: string): Promise<ListObjectsResult>;
+    /** `HeadObject` — fetch an object's metadata without its body. Throws (NotFound) if the object doesn't exist. */
+    headObject(bucket: string, key: string): Promise<HeadObjectResult>;
+    /**
+     * Whether an object exists, implemented via `HeadObject`. Returns `false`
+     * when R2 reports the object is missing (a `NotFound` / 404 error) rather
+     * than throwing; any other error (e.g. access denied) is re-thrown.
+     */
+    objectExists(bucket: string, key: string): Promise<boolean>;
+    /**
+     * Recognize "object does not exist" errors across the shapes the SDK (and
+     * its wrapped form here) can surface them: the raw error's `.name`
+     * (`NotFound`, `NoSuchKey`), its HTTP status (404), or the wrapped
+     * `DatabaseError`'s `.parent`.
+     */
+    private isNotFound;
+}
+export default R2Store;

package/dist/nosql/rabbitmq/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * RabbitMQ (AMQP 0-9-1) store.
+ *
+ * RabbitMQ is a message broker, not a database: there is no query language,
+ * no relational schema, and no `query(sql)` shape. Producers publish
+ * messages to *exchanges*, which route them (by binding key/pattern) into
+ * *queues*, from which *consumers* read. Like the other stores in
+ * `src/nosql/`, this class therefore does not implement the SQL-shaped
+ * `Dialect` interface (`src/dialects/dialect.ts`). Instead it implements the
+ * minimal `NoSqlStore` marker interface (`src/nosql/store.ts`) and exposes
+ * RabbitMQ's real operations — assert/bind topology, publish, and consume —
+ * directly, mapped onto a single AMQP channel.
+ *
+ * Uses the official `amqplib` driver. `amqplib` is an optional peer of this
+ * ORM and is loaded lazily (via `require`) inside `connect()`, so importing
+ * this module does not require `amqplib` to be installed unless you actually
+ * connect. For tests (and for advanced setups that manage the AMQP
+ * connection themselves), a pre-built connection can be injected via
+ * `RabbitMQStoreOptions.connection`, in which case `connect()` uses it and
+ * skips the `require` entirely.
+ *
+ * ## Message serialization
+ *
+ * AMQP message bodies are raw bytes (`Buffer`). For convenience, both
+ * `sendToQueue()` and `publish()` accept any value: a `Buffer` (or
+ * `Uint8Array`) is sent as-is, a `string` is UTF-8 encoded, and anything
+ * else is serialized with `JSON.stringify` before being wrapped in a
+ * `Buffer`. Consumers receive the raw `amqplib` message object; decode
+ * `msg.content` (a `Buffer`) yourself (e.g. `JSON.parse(msg.content.toString())`).
+ */
+import type { NoSqlStore } from '../store';
+/**
+ * Connection options for `RabbitMQStore`.
+ *
+ * `amqplib` ships no types the ORM depends on here, so its connection and
+ * channel are typed as `any` — the repo's tsconfig has `noImplicitAny:
+ * false`, the intended escape hatch for optional, untyped drivers.
+ */
+export interface RabbitMQStoreOptions {
+    /**
+     * AMQP connection URL, e.g. `'amqp://guest:guest@localhost:5672'` or
+     * `'amqps://host'`. Used by `connect()` when no `connection` is injected.
+     * Defaults to `'amqp://localhost'`.
+     */
+    url?: string;
+    /**
+     * A pre-built `amqplib` connection (the object returned by
+     * `amqp.connect(...)`). When provided, `connect()` adopts it and does not
+     * `require('amqplib')` — useful for sharing one connection across stores,
+     * or for injecting a mock in tests.
+     */
+    connection?: any;
+}
+/** A value acceptable as an AMQP message body: raw bytes, a string, or any JSON-serializable value. */
+export type RabbitMQMessage = Buffer | Uint8Array | string | unknown;
+/**
+ * `RabbitMQStore` wraps a single `amqplib` channel and exposes RabbitMQ's
+ * core AMQP operations: asserting queues/exchanges, binding them, publishing
+ * (to a queue directly or via an exchange), consuming with ack/nack, and
+ * consumer prefetch (QoS).
+ */
+export declare class RabbitMQStore implements NoSqlStore {
+    readonly name = "rabbitmq";
+    readonly library = "amqplib";
+    private readonly options;
+    private connection;
+    private channel;
+    private connected;
+    constructor(options?: RabbitMQStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `amqplib` channel for operations not wrapped here. */
+    getClient(): any;
+    /** Returns the underlying `amqplib` connection. */
+    getConnection(): any;
+    private requireChannel;
+    private exec;
+    /**
+     * Declare a queue, creating it if it doesn't exist (idempotent). Returns
+     * amqplib's assertion reply (`{ queue, messageCount, consumerCount }`).
+     * Pass `''` as `queue` to have the broker generate a unique name.
+     */
+    assertQueue(queue: string, options?: any): Promise<any>;
+    /**
+     * Declare an exchange of the given `type` (`'direct'`, `'fanout'`,
+     * `'topic'`, `'headers'`), creating it if it doesn't exist (idempotent).
+     */
+    assertExchange(exchange: string, type: string, options?: any): Promise<any>;
+    /**
+     * Bind `queue` to `exchange` so messages published to `exchange` matching
+     * `pattern` (the routing/binding key) are routed into `queue`.
+     */
+    bindQueue(queue: string, exchange: string, pattern: string): Promise<any>;
+    /**
+     * Send a message straight to a named `queue` (via the default exchange).
+     * Non-`Buffer` messages are serialized — strings UTF-8 encoded, other
+     * values `JSON.stringify`'d (see the module docs). Returns amqplib's
+     * boolean write result (`false` when the channel's write buffer is full
+     * and you should wait for a `'drain'` event before writing more).
+     */
+    sendToQueue(queue: string, message: RabbitMQMessage, options?: any): Promise<boolean>;
+    /**
+     * Publish a message to an `exchange` with a `routingKey`; the exchange
+     * routes it to bound queues. Non-`Buffer` messages are serialized like
+     * `sendToQueue()`. Returns amqplib's boolean write result.
+     */
+    publish(exchange: string, routingKey: string, message: RabbitMQMessage, options?: any): Promise<boolean>;
+    /**
+     * Register `handler` to receive each message delivered from `queue`. The
+     * handler is called with the raw amqplib message object (or `null` if the
+     * consumer is cancelled by the broker); decode `msg.content` yourself.
+     * Unless `options.noAck` is set, call `ack(msg)`/`nack(msg)` when done.
+     * Returns amqplib's `{ consumerTag }` reply.
+     */
+    consume(queue: string, handler: (msg: any) => void, options?: any): Promise<any>;
+    /** Acknowledge a delivered message so the broker can drop it. */
+    ack(message: any, allUpTo?: boolean): void;
+    /**
+     * Reject a delivered message. By default RabbitMQ requeues it (`requeue`
+     * defaults to `true` in amqplib); pass `requeue = false` to drop or
+     * dead-letter it.
+     */
+    nack(message: any, allUpTo?: boolean, requeue?: boolean): void;
+    /**
+     * Set the consumer prefetch (QoS) — the max number of unacknowledged
+     * messages the broker will deliver to consumers on this channel at once.
+     */
+    prefetch(count: number, global?: boolean): Promise<any>;
+}
+export default RabbitMQStore;