ts-prorm-orm 1.1.0 → 1.2.0

package/dist/nosql/arangodb/where.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWhere = parseWhere;
+exports.escapeRegex = escapeRegex;
+exports.likeToRegex = likeToRegex;
+/**
+ * ORM where-clause parser for the ArangoDB store.
+ *
+ * Turns the ORM's `where` shape (plain-object field conditions, `Op.*`
+ * comparison symbols, and `Op.and`/`Op.or`/`Op.not` logical symbols) into a
+ * small, store-agnostic {@link WhereNode} tree that the store then renders to
+ * an AQL FILTER clause. This is what lets callers write standard ORM
+ * queries (`{ age: { [Op.gte]: 18 } }`) instead of hand-building ReQL row
+ * predicates.
+ */
+const operators_1 = require("../../operators");
+/** Whether `v` is a plain object carrying `Op.*` comparison symbols (e.g. `{ [Op.gt]: 5 }`). */
+function hasOpSymbols(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        !Array.isArray(v) &&
+        Object.getOwnPropertySymbols(v).length > 0);
+}
+/**
+ * Parse an ORM `where` object into a {@link WhereNode} tree.
+ *
+ * - String keys are field conditions: a scalar means equality, an array means
+ *   `Op.in`, and a nested `{ [Op.*]: value }` object expands to one comparison
+ *   per operator.
+ * - `Op.and`/`Op.or` take an array of sub-`where` objects; `Op.not` negates a
+ *   single sub-`where`.
+ */
+function parseWhere(where) {
+    if (!where)
+        return { kind: 'true' };
+    const nodes = [];
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const val = where[sym];
+        if (sym === operators_1.Op.and) {
+            nodes.push({ kind: 'and', nodes: asArray(val).map(parseWhere) });
+        }
+        else if (sym === operators_1.Op.or) {
+            nodes.push({ kind: 'or', nodes: asArray(val).map(parseWhere) });
+        }
+        else if (sym === operators_1.Op.not) {
+            nodes.push({ kind: 'not', node: parseWhere(val) });
+        }
+    }
+    for (const field of Object.keys(where)) {
+        const val = where[field];
+        if (hasOpSymbols(val)) {
+            for (const opSym of Object.getOwnPropertySymbols(val)) {
+                nodes.push({ kind: 'cmp', field, op: opSym, value: val[opSym] });
+            }
+            continue;
+        }
+        if (Array.isArray(val)) {
+            nodes.push({ kind: 'cmp', field, op: operators_1.Op.in, value: val });
+        }
+        else {
+            nodes.push({ kind: 'cmp', field, op: operators_1.Op.eq, value: val });
+        }
+    }
+    if (nodes.length === 0)
+        return { kind: 'true' };
+    if (nodes.length === 1)
+        return nodes[0];
+    return { kind: 'and', nodes };
+}
+function asArray(v) {
+    return (Array.isArray(v) ? v : [v]);
+}
+/** Escape a string for safe inclusion in a regular expression. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Translate a SQL `LIKE`/`ILIKE` pattern into an anchored regular expression
+ * (`%` → `.*`, `_` → `.`), so stores that only speak regex can honor ORM
+ * `Op.like` queries without the caller hand-writing a pattern.
+ */
+function likeToRegex(pattern, caseInsensitive = false) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += escapeRegex(ch);
+    }
+    return `${caseInsensitive ? '(?i)' : ''}^${out}$`;
+}

package/dist/nosql/azure-blob/index.d.ts

@@ -0,0 +1,104 @@
+import type { NoSqlStore } from '../store';
+/**
+ * Minimal structural view of the pieces of `@azure/storage-blob` this store
+ * uses. Kept `any`-ish/loose on purpose: the real SDK types aren't available
+ * at build time (the package is an optional, lazy-loaded dependency), so we
+ * describe just the method chain we call rather than depending on its types.
+ */
+export interface BlockBlobClientLike {
+    upload(data: unknown, contentLength: number, options?: unknown): Promise<unknown>;
+    uploadData?(data: unknown, options?: unknown): Promise<unknown>;
+    download(offset?: number, count?: number, options?: unknown): Promise<BlobDownloadResponseLike>;
+    delete(options?: unknown): Promise<unknown>;
+    exists(options?: unknown): Promise<boolean>;
+}
+export interface ContainerClientLike {
+    getBlockBlobClient(blobName: string): BlockBlobClientLike;
+    listBlobsFlat(options?: {
+        prefix?: string;
+    }): AsyncIterable<{
+        name: string;
+    }>;
+    create(options?: unknown): Promise<unknown>;
+}
+export interface BlobServiceClientLike {
+    getContainerClient(containerName: string): ContainerClientLike;
+}
+/** Shape of the response returned by `BlockBlobClient.download()`. */
+export interface BlobDownloadResponseLike {
+    /** Node.js readable stream body (server-side). */
+    readableStreamBody?: NodeJS.ReadableStream;
+    /** Browser blob body (only present in the browser build). */
+    blobBody?: Promise<{
+        arrayBuffer(): Promise<ArrayBuffer>;
+    }>;
+    /** Convenience accessor exposed by the SDK's browser build. */
+    contentAsBlob?: Promise<{
+        arrayBuffer(): Promise<ArrayBuffer>;
+    }>;
+}
+/**
+ * Connection options for `AzureBlobStore`.
+ *
+ * Provide exactly one of:
+ *  - `client`: a pre-built `BlobServiceClient` (used as-is; the SDK is not
+ *    `require()`d — this is how tests inject a mock).
+ *  - `connectionString`: an Azure Storage connection string, used to build a
+ *    client via `BlobServiceClient.fromConnectionString(...)`.
+ *  - `account` + `accountKey`: builds a connection string from an account
+ *    name and key (convenience over `connectionString`).
+ */
+export interface AzureBlobStoreOptions {
+    /** A pre-built `BlobServiceClient`. When given, `connect()` uses it directly and never loads the SDK. */
+    client?: BlobServiceClientLike;
+    /** Azure Storage connection string, e.g. `DefaultEndpointsProtocol=https;AccountName=...;AccountKey=...;`. */
+    connectionString?: string;
+    /** Storage account name (used with `accountKey` to synthesize a connection string). */
+    account?: string;
+    /** Storage account key (used with `account`). */
+    accountKey?: string;
+    /** Endpoint suffix for the synthesized connection string. Defaults to `core.windows.net`. */
+    endpointSuffix?: string;
+}
+/** Data acceptable for `uploadBlob()` — a Buffer, string, or byte view. */
+export type BlobUploadData = Buffer | string | Uint8Array | ArrayBuffer;
+/**
+ * `AzureBlobStore` wraps a `@azure/storage-blob` `BlobServiceClient` and
+ * exposes Azure Blob Storage's object-level operations. It implements the
+ * minimal `NoSqlStore` marker interface — there is no `query(sql)` because
+ * Blob Storage has no query language; access is by container + blob name.
+ */
+export declare class AzureBlobStore implements NoSqlStore {
+    readonly name = "azure-blob";
+    readonly library = "@azure/storage-blob";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: AzureBlobStoreOptions);
+    connect(): Promise<void>;
+    private resolveConnectionString;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `BlobServiceClient` for anything not wrapped here. */
+    getClient(): BlobServiceClientLike;
+    private requireClient;
+    private blockBlob;
+    private wrapError;
+    /** Uploads `data` to `container`/`key`, creating or overwriting the block blob. */
+    uploadBlob(container: string, key: string, data: BlobUploadData): Promise<void>;
+    /** Downloads `container`/`key` and returns its full contents as a Buffer. */
+    downloadBlob(container: string, key: string): Promise<Buffer>;
+    /** Deletes `container`/`key`. */
+    deleteBlob(container: string, key: string): Promise<void>;
+    /** Returns whether `container`/`key` exists. */
+    blobExists(container: string, key: string): Promise<boolean>;
+    /**
+     * Lists the names of all blobs in `container`, optionally filtered to those
+     * whose name starts with `prefix`. Iterates the SDK's async paging iterator
+     * (`listBlobsFlat`) fully and returns a flat array of blob names.
+     */
+    listBlobs(container: string, prefix?: string): Promise<string[]>;
+    /** Creates `container`. */
+    createContainer(container: string): Promise<void>;
+}
+export default AzureBlobStore;

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

@@ -0,0 +1,88 @@
+/**
+ * Beanstalkd job/work-queue store.
+ *
+ * Beanstalkd is a simple, fast work queue. Producers `put` jobs (opaque byte
+ * payloads) into named *tubes*; workers `reserve` jobs from the tubes they
+ * `watch`, do the work, then `delete` (destroy) them. It is not a database:
+ * there is no query language and it does not fit the SQL-shaped `Dialect`
+ * interface, so this class implements the minimal `NoSqlStore` marker
+ * interface and exposes Beanstalkd's real queue operations instead.
+ *
+ * Uses the `fivebeans` driver, whose client exposes a callback-style API
+ * (`client.put(pri, delay, ttr, payload, cb)` etc.); this store promisifies
+ * those calls internally so its surface is promise-based. `fivebeans` is an
+ * optional peer and is loaded lazily (via `require`) inside `connect()`, so
+ * importing this module does not require it to be installed unless you
+ * actually connect. A pre-built client can be injected via
+ * `BeanstalkdStoreOptions.client`, in which case `connect()` adopts it and
+ * skips the `require` entirely (used by the unit tests to inject a mock).
+ */
+import type { NoSqlStore } from '../store';
+/** Connection options for `BeanstalkdStore`. */
+export interface BeanstalkdStoreOptions {
+    /** Beanstalkd host. Defaults to `'127.0.0.1'`. */
+    host?: string;
+    /** Beanstalkd port. Defaults to `11300`. */
+    port?: number;
+    /**
+     * A pre-built `fivebeans` client. When provided, `connect()` adopts it and
+     * does not `require('fivebeans')` — used for injecting a mock in tests.
+     */
+    client?: any;
+}
+/** Options for `enqueue()` (map onto fivebeans' `put(pri, delay, ttr, ...)`). */
+export interface BeanstalkdPutOptions {
+    /** Job priority (smaller runs first). Defaults to `0`. */
+    priority?: number;
+    /** Seconds to delay before the job becomes ready. Defaults to `0`. */
+    delay?: number;
+    /** Time-to-run: seconds a worker has to finish before requeue. Defaults to `60`. */
+    ttr?: number;
+}
+/** A reserved Beanstalkd job handed to a `process()` handler. */
+export interface BeanstalkdJob {
+    id: string;
+    payload: string;
+}
+/**
+ * `BeanstalkdStore` wraps a single `fivebeans` client and exposes the common
+ * queue surface (`enqueue`/`process`/`getJob`/`remove`/`stats`) over
+ * Beanstalkd tubes, promisifying the driver's callback API.
+ */
+export declare class BeanstalkdStore implements NoSqlStore {
+    readonly name = "beanstalkd";
+    readonly library = "fivebeans";
+    private readonly options;
+    private client;
+    private connected;
+    /** Set false on disconnect to break any running `process()` reserve loop. */
+    private running;
+    constructor(options?: BeanstalkdStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `fivebeans` client for operations not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    /** Promisify a callback-style client method whose callback is `(err, result)`. */
+    private call;
+    /**
+     * Enqueue a job into a tube. Selects the tube via `use()`, then `put()`s the
+     * (JSON-serialized) payload with the given priority/delay/ttr. Returns the
+     * job id assigned by the server.
+     */
+    enqueue(queue: string, jobData: unknown, opts?: BeanstalkdPutOptions): Promise<string>;
+    /**
+     * Register a worker on a tube: `watch()` it, then loop `reserve()`ing jobs
+     * and invoking `handler(job)`. After the handler resolves the job is
+     * `destroy()`ed. The loop stops when the store disconnects.
+     */
+    process(queue: string, handler: (job: BeanstalkdJob) => void | Promise<void>): Promise<void>;
+    /** Peek at a job by id, returning its id and payload (or `null` if absent). */
+    getJob(_queue: string, id: string): Promise<BeanstalkdJob | null>;
+    /** Delete (destroy) a job by id. */
+    remove(_queue: string, id: string): Promise<void>;
+    /** Return per-tube statistics (`stats-tube`), e.g. ready/reserved/buried counts. */
+    stats(queue: string): Promise<any>;
+}
+export default BeanstalkdStore;

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

@@ -0,0 +1,99 @@
+/**
+ * Bee-Queue job/task-queue store.
+ *
+ * Bee-Queue is a fast, lightweight Redis-backed job queue. A single `Queue`
+ * object (bound to a queue name) both produces jobs — `queue.createJob(data)`
+ * built into a job, then `.save()`d — and consumes them via
+ * `queue.process(handler)`. Each queue is a distinct object per name, so this
+ * store caches one `Queue` per queue name. It is not a database and does not
+ * fit the SQL-shaped `Dialect` interface, so this class implements the
+ * minimal `NoSqlStore` marker interface and exposes Bee-Queue's real
+ * create/process/getJob operations instead.
+ *
+ * Uses the `bee-queue` driver, whose default export is the `Queue`
+ * constructor. It is an optional peer loaded lazily (via `require`) inside
+ * `connect()`, so importing this module does not require it to be installed
+ * unless you actually connect. A pre-built `Queue` constructor can be
+ * injected via `BeeQueueStoreOptions.client`, in which case `connect()`
+ * adopts it and skips the `require` entirely (used by the unit tests to
+ * inject a mock).
+ */
+import type { NoSqlStore } from '../store';
+/** Connection options for `BeeQueueStore`. */
+export interface BeeQueueStoreOptions {
+    /**
+     * Bee-Queue settings passed to every `Queue` (e.g. `{ redis: { host, port
+     * } }`, `isWorker`, `removeOnSuccess`). Defaults to
+     * `{ redis: { host: '127.0.0.1', port: 6379 } }`.
+     */
+    settings?: any;
+    /**
+     * A pre-built `bee-queue` `Queue` constructor (or a stand-in). When
+     * provided, `connect()` adopts it and does not `require('bee-queue')` —
+     * used for injecting a mock in tests.
+     */
+    client?: any;
+}
+/** Options for `enqueue()` mapped onto Bee-Queue job builder methods. */
+export interface BeeQueueEnqueueOptions {
+    /** Retry the job up to this many times on failure (`job.retries(n)`). */
+    retries?: number;
+    /** Delay the job until this timestamp/ms (`job.delayUntil(...)`). */
+    delayUntil?: number | Date;
+    /** Set the job timeout in ms (`job.timeout(n)`). */
+    timeout?: number;
+}
+/** Options for `process()`. */
+export interface BeeQueueProcessOptions {
+    /** Max jobs to run concurrently on this worker. Defaults to `1`. */
+    concurrency?: number;
+}
+/**
+ * `BeeQueueStore` manages a pool of Bee-Queue `Queue` objects keyed by queue
+ * name and exposes the common queue surface
+ * (`enqueue`/`process`/`getJob`/`remove`/`stats`).
+ */
+export declare class BeeQueueStore implements NoSqlStore {
+    readonly name = "beequeue";
+    readonly library = "bee-queue";
+    private readonly options;
+    private Queue;
+    private connected;
+    private readonly queues;
+    /** Queue names that already have a `process()` handler registered. */
+    private readonly processing;
+    constructor(options?: BeeQueueStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `bee-queue` `Queue` constructor. */
+    getClient(): any;
+    private requireDriver;
+    private get settings();
+    /** Get (creating and caching on first use) the `Queue` for a queue name. */
+    private getQueue;
+    /**
+     * Build a job with `queue.createJob(data)`, apply any retry/delay/timeout
+     * options, `.save()` it, and return the id Bee-Queue assigns.
+     */
+    enqueue(queue: string, jobData: unknown, opts?: BeeQueueEnqueueOptions): Promise<string>;
+    /**
+     * Register the worker handler for a queue via `queue.process(concurrency,
+     * handler)`. Bee-Queue allows only one `process()` per Queue object, so a
+     * repeat call on the same queue name is a no-op.
+     */
+    process(queue: string, handler: (job: any) => any | Promise<any>, opts?: BeeQueueProcessOptions): Promise<any>;
+    /** Fetch a job by id from the named queue (`queue.getJob(id)`). */
+    getJob(queue: string, id: string): Promise<any>;
+    /**
+     * Remove a job by id from the named queue. Uses `queue.removeJob(id)` when
+     * available, otherwise fetches the job and calls `job.remove()`.
+     */
+    remove(queue: string, id: string): Promise<void>;
+    /**
+     * Return job counts by state for a queue. Uses `queue.getJobCounts()` when
+     * available, otherwise falls back to Bee-Queue's `queue.checkHealth()`.
+     */
+    stats(queue: string): Promise<any>;
+}
+export default BeeQueueStore;

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

@@ -0,0 +1,113 @@
+/**
+ * BigchainDB store implementation.
+ *
+ * BigchainDB is a blockchain database: data is written as cryptographically
+ * signed, immutable **transactions** over **assets**. A CREATE transaction
+ * registers a new asset (with arbitrary immutable `asset.data` and mutable
+ * `metadata`); TRANSFER transactions spend prior outputs. Because every
+ * transaction is Ed25519-signed and content-addressed by its hash (`tx.id`),
+ * the ledger is append-only and tamper-evident by construction.
+ *
+ * BigchainDB is not a SQL `Dialect`, so this class implements the minimal
+ * `NoSqlStore` marker interface plus the shared ledger surface:
+ *  - `append(table, data)` -> build + sign + commit a CREATE transaction
+ *    whose asset carries `{ table, ...data }`, returning the new `tx.id`.
+ *  - `get(table, id)`      -> fetch a transaction by id.
+ *  - `history(table, id)`  -> list all transactions for the asset `id`.
+ *  - `verify(table, id)`   -> return the signed transaction (its signatures
+ *    and content hash are the proof of integrity).
+ *  - `query(text)`         -> full-text asset search (`searchAssets`).
+ *
+ * ## Lazy driver loading
+ *
+ * `bigchaindb-driver` is loaded lazily inside `connect()`. Tests inject a
+ * pre-built connection via `BigchaindbStoreOptions.client` and the transaction
+ * factory via `BigchaindbStoreOptions.transaction`, bypassing the `require`.
+ */
+import { NoSqlStore } from '../store';
+/** A BigchainDB keypair (Ed25519, base58-encoded). */
+export interface BigchaindbKeypair {
+    publicKey: string;
+    privateKey: string;
+}
+/** The subset of `bigchaindb-driver`'s `Connection` this store uses. */
+export interface BigchaindbConnectionLike {
+    postTransactionCommit(tx: unknown): Promise<any>;
+    getTransaction(txId: string): Promise<any>;
+    listTransactions?(opts: {
+        asset_id: string;
+        operation?: string;
+    }): Promise<any>;
+    searchAssets?(text: string): Promise<any>;
+    listOutputs?(opts: {
+        public_key: string;
+        spent?: boolean;
+    }): Promise<any>;
+}
+/** The subset of `bigchaindb-driver`'s `Transaction` namespace this store uses. */
+export interface BigchaindbTransactionFactory {
+    makeCreateTransaction(asset: unknown, metadata: unknown, outputs: unknown[], ...issuers: string[]): any;
+    makeTransferTransaction?(...args: unknown[]): any;
+    makeOutput(condition: unknown, amount?: string): any;
+    makeEd25519Condition(publicKey: string, json?: boolean): any;
+    signTransaction(transaction: unknown, ...privateKeys: string[]): any;
+}
+/** Connection options for `BigchaindbStore`. */
+export interface BigchaindbStoreOptions {
+    /** BigchainDB API root, e.g. `'http://localhost:9984/api/v1/'`. */
+    url?: string;
+    /** Extra headers (e.g. an `app_id`/`app_key` for hosted BigchainDB). */
+    headers?: Record<string, string>;
+    /** Keypair used to sign CREATE transactions in `append`. Required to write. */
+    keypair?: BigchaindbKeypair;
+    /** A pre-built `Connection` to use instead of the lazy `require`. */
+    client?: BigchaindbConnectionLike;
+    /** A pre-built `Transaction` factory (injected in tests alongside `client`). */
+    transaction?: BigchaindbTransactionFactory;
+}
+/**
+ * `BigchaindbStore` wraps a `bigchaindb-driver` connection + transaction
+ * factory behind the shared ledger surface.
+ */
+export declare class BigchaindbStore implements NoSqlStore {
+    readonly name = "bigchaindb";
+    readonly library = "bigchaindb-driver";
+    private readonly options;
+    private conn;
+    private txFactory;
+    private connected;
+    constructor(options?: BigchaindbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `Connection` for anything not wrapped here. */
+    getClient(): BigchaindbConnectionLike;
+    private requireConn;
+    private requireTxFactory;
+    /**
+     * Build, sign and commit a CREATE transaction registering a new asset whose
+     * immutable `asset.data` is `{ table, ...data }`. Returns the resulting
+     * transaction id (its content hash). Requires `options.keypair`.
+     */
+    append(table: string, data: Record<string, unknown>): Promise<string>;
+    /** Fetch a transaction by its id (`get(_, id)`). Returns the signed transaction. */
+    get(_table: string, id: string): Promise<unknown>;
+    /**
+     * List every transaction (CREATE + subsequent TRANSFERs) for the asset `id`
+     * - the append-only history of that asset. Uses `listTransactions`.
+     */
+    history(_table: string, id: string): Promise<unknown>;
+    /**
+     * Return the signed transaction `id` as its own proof of integrity: its
+     * Ed25519 signatures and content-hash id are what any party independently
+     * re-verifies against the asset data. Returns `{ id, valid, transaction }`.
+     */
+    verify(_table: string, id: string): Promise<{
+        id: string;
+        valid: boolean;
+        transaction: unknown;
+    }>;
+    /** Full-text search over asset data via `searchAssets`. */
+    query(text: string): Promise<unknown>;
+}
+export default BigchaindbStore;

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

@@ -0,0 +1,144 @@
+import type { NoSqlStore } from '../store';
+/**
+ * A map of column-family names to `{ qualifier: value }` maps, matching the
+ * `@google-cloud/bigtable` `insert` entry `data` shape, e.g.
+ * `{ cf: { name: 'alice', age: 30 } }`.
+ */
+export type BigtableRowData = Record<string, Record<string, unknown>>;
+/**
+ * Minimal structural type for the `Row` handle `table.row(key)` returns.
+ * Each method returns a promise (the client's promise-style API).
+ */
+export interface BigtableRowLike {
+    get(): Promise<unknown>;
+    delete(): Promise<unknown>;
+}
+/**
+ * Minimal structural type for the `Table` handle `instance.table(id)` returns.
+ */
+export interface BigtableTableLike {
+    insert(entries: unknown): Promise<unknown>;
+    getRows(options?: Record<string, unknown>): Promise<unknown>;
+    row(key: string): BigtableRowLike;
+    create(options?: Record<string, unknown>): Promise<unknown>;
+}
+/** Minimal structural type for the `Instance` handle `client.instance(id)` returns. */
+export interface BigtableInstanceLike {
+    table(id: string): BigtableTableLike;
+}
+/**
+ * Minimal structural type for the pieces of a `@google-cloud/bigtable`
+ * `Bigtable` client this store uses. Kept local (rather than importing from
+ * `@google-cloud/bigtable`) so this module type-checks without the optional
+ * driver installed.
+ */
+export interface BigtableClientLike {
+    instance(id: string): BigtableInstanceLike;
+}
+/** Options accepted by `readRows()`; forwarded straight to `table.getRows`. */
+export interface BigtableReadOptions {
+    /** Inclusive/exclusive key range for the scan. */
+    ranges?: Array<{
+        start?: string;
+        end?: string;
+    }>;
+    /** Explicit list of row keys to read. */
+    keys?: string[];
+    /** A prefix all returned row keys must share. */
+    prefix?: string;
+    /** Maximum number of rows to return. */
+    limit?: number;
+    /** A Bigtable read filter (family/qualifier/value/regex filters). */
+    filter?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Connection options for `BigtableStore`. `projectId`, `instanceId`, and
+ * `tableId` locate the resource; the latter two are configurable defaults —
+ * every row method also accepts an explicit `table` name to target a different
+ * table within the same instance.
+ */
+export interface BigtableStoreOptions {
+    /** GCP project id that owns the Bigtable instance. */
+    projectId?: string;
+    /** Bigtable instance id, used as the default for all table operations. */
+    instanceId?: string;
+    /** Default table id, used when a method's `table` argument is omitted. */
+    tableId?: string;
+    /**
+     * Escape hatch for any other `Bigtable` constructor option (keyFilename,
+     * credentials, apiEndpoint for the emulator, ...). Merged into the options
+     * passed to `new Bigtable(...)`.
+     */
+    clientOptions?: Record<string, unknown>;
+    /**
+     * A pre-built `Bigtable` client (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('@google-cloud/bigtable')`
+     * entirely — this is how tests inject a mock without the real driver
+     * installed.
+     */
+    client?: BigtableClientLike;
+}
+/**
+ * `BigtableStore` wraps a `@google-cloud/bigtable` client and exposes
+ * Bigtable's row surface: `insertRow`/`getRow`/`deleteRow` for single-row
+ * operations, `readRows` for range/filter scans, and `createTable` for
+ * defining a table's column families. Instance and table ids are resolved once
+ * and the resulting handles cached per table id.
+ */
+export declare class BigtableStore implements NoSqlStore {
+    readonly name = "bigtable";
+    readonly library = "@google-cloud/bigtable";
+    private readonly options;
+    private client;
+    private instance;
+    private readonly tables;
+    private connected;
+    constructor(options?: BigtableStoreOptions);
+    connect(): Promise<void>;
+    /**
+     * The Bigtable client manages its own gRPC channel pool and does not expose
+     * a public close on the surface this store depends on, so `disconnect()`
+     * drops the cached handles and flips `connected` to false.
+     */
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `Bigtable` client for anything not wrapped here. */
+    getClient(): BigtableClientLike;
+    private requireClient;
+    /**
+     * Resolves (and caches) the `Table` handle for `table` (or the configured
+     * default `tableId`) within the configured instance. Requires both an
+     * instance id and a table id to be resolvable.
+     */
+    private tableFor;
+    private wrapError;
+    /**
+     * Inserts (writes) a single row via `table.insert(...)`. `data` maps column
+     * families to `{ qualifier: value }` maps, e.g.
+     * `{ cf: { name: 'alice', age: 30 } }`. Passed to the driver as a single
+     * `{ key, data }` insert entry.
+     */
+    insertRow(table: string, key: string, data: BigtableRowData): Promise<unknown>;
+    /** Reads a single row by key via `table.row(key).get()`, returning the row data. */
+    getRow(table: string, key: string): Promise<unknown>;
+    /** Deletes an entire row (all its cells) via `table.row(key).delete()`. */
+    deleteRow(table: string, key: string): Promise<unknown>;
+    /**
+     * Reads multiple rows via `table.getRows(options)`. `options` (ranges, keys,
+     * prefix, limit, filter) is forwarded straight to the client. Since Bigtable
+     * keeps row keys sorted, a `ranges`/`prefix` scan reads an efficient
+     * contiguous slice of the key space. Returns the rows as the driver
+     * surfaces them.
+     */
+    readRows(table: string, opts?: BigtableReadOptions): Promise<unknown>;
+    /**
+     * Creates a table with the given column families via `table.create(...)`.
+     * `families` is the list of column family names (e.g. `['cf', 'meta']`),
+     * passed to the client as its `families` create option. A table must declare
+     * its families up front — unlike qualifiers, families cannot be added
+     * implicitly at write time.
+     */
+    createTable(table: string, families: string[]): Promise<unknown>;
+}
+export default BigtableStore;