ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,122 @@
+import type { NoSqlStore } from '../store';
+/**
+ * A single statement for `batch()`: a CQL string plus its bound parameters.
+ * Mirrors the `cassandra-driver` batch query shape.
+ */
+export interface KeyspacesBatchQuery {
+    query: string;
+    params?: unknown[];
+}
+/**
+ * Options for `execute()` / `batch()`. Forwarded straight through to the
+ * driver's query-options bag (consistency, fetchSize, pageState, timestamp,
+ * etc.). `prepare` defaults to `true` here (see `execute()`), overridable per
+ * call. Note Keyspaces' default consistency is `LOCAL_QUORUM`.
+ */
+export interface KeyspacesQueryOptions {
+    prepare?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * The shape of a `cassandra-driver` result. Only `rows` is relied on here; the
+ * rest of the driver's result metadata is preserved via the index signature.
+ */
+export interface KeyspacesResult<T = Record<string, unknown>> {
+    rows?: T[];
+    [key: string]: unknown;
+}
+/**
+ * Minimal structural type for the pieces of a `cassandra-driver` `Client` this
+ * store uses. Kept local so this module type-checks without the optional
+ * driver installed.
+ */
+export interface KeyspacesClientLike {
+    connect(): Promise<void>;
+    execute(query: string, params?: unknown[], options?: Record<string, unknown>): Promise<KeyspacesResult>;
+    batch(queries: KeyspacesBatchQuery[], options?: Record<string, unknown>): Promise<KeyspacesResult>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Connection options for `KeyspacesStore`. These map onto the `cassandra-driver`
+ * `Client` constructor options. For a real Keyspaces endpoint, TLS `sslOptions`
+ * and a SigV4/credentials `authProvider` are supplied through `clientOptions`.
+ */
+export interface KeyspacesStoreOptions {
+    /**
+     * Keyspaces service endpoint(s), e.g.
+     * `['cassandra.us-east-1.amazonaws.com:9142']` (note the TLS port 9142).
+     */
+    contactPoints?: string[];
+    /** Local data center — typically the AWS region, e.g. `'us-east-1'`. */
+    localDataCenter?: string;
+    /** Default keyspace to bind the session to. */
+    keyspace?: string;
+    /** Service-specific username/password credentials (or use a SigV4 authProvider via clientOptions). */
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    /**
+     * Escape hatch for any other `cassandra-driver` `Client` option. For
+     * Keyspaces this is where TLS (`sslOptions`) and the SigV4 `authProvider`
+     * live. Merged into the options passed to the `Client` constructor.
+     */
+    clientOptions?: Record<string, unknown>;
+    /**
+     * A pre-built driver `Client` (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('cassandra-driver')`
+     * entirely — this is how tests inject a mock without the real driver
+     * installed.
+     */
+    client?: KeyspacesClientLike;
+}
+/**
+ * `KeyspacesStore` wraps a `cassandra-driver` `Client` pointed at an Amazon
+ * Keyspaces endpoint and exposes CQL execution (`execute`), atomic
+ * multi-statement batches (`batch`), and a few parameterized convenience
+ * helpers (`insert`, `selectAll`).
+ *
+ * Statements are prepared by default (`prepare: true`). All Keyspaces-specific
+ * connection concerns (TLS, SigV4/credentials, LOCAL_QUORUM consistency) are
+ * plain driver options and pass through via `clientOptions` or a pre-built
+ * `client`.
+ */
+export declare class KeyspacesStore implements NoSqlStore {
+    readonly name = "keyspaces";
+    readonly library = "cassandra-driver";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: KeyspacesStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `cassandra-driver` `Client` for anything not wrapped here. */
+    getClient(): KeyspacesClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Execute a single CQL statement with optional bound `params`. Statements
+     * are prepared by default (`prepare: true`); pass `opts.prepare = false` to
+     * run a one-off unprepared. Any other driver query options (including
+     * `consistency`, which defaults to `LOCAL_QUORUM` on Keyspaces) are forwarded
+     * via `opts`. Returns the full driver result (with `.rows`).
+     */
+    execute<T = Record<string, unknown>>(query: string, params?: unknown[], opts?: KeyspacesQueryOptions): Promise<KeyspacesResult<T>>;
+    /**
+     * Execute multiple statements as a single logged batch. Each entry is a
+     * `{ query, params }` pair. Prepared by default; forward other driver batch
+     * options via `opts`.
+     */
+    batch(queries: KeyspacesBatchQuery[], opts?: KeyspacesQueryOptions): Promise<KeyspacesResult>;
+    /**
+     * Convenience `INSERT`: builds a parameterized
+     * `INSERT INTO table (cols...) VALUES (?, ?, ...)` from `obj`'s keys and
+     * executes it (prepared). For upserts with TTL, IF NOT EXISTS, or other
+     * clauses, write the CQL yourself and call `execute()`.
+     */
+    insert(table: string, obj: Record<string, unknown>, opts?: KeyspacesQueryOptions): Promise<KeyspacesResult>;
+    /** Convenience `SELECT * FROM table`. Returns the full driver result (with `.rows`). */
+    selectAll<T = Record<string, unknown>>(table: string, opts?: KeyspacesQueryOptions): Promise<KeyspacesResult<T>>;
+}
+export default KeyspacesStore;

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

@@ -0,0 +1,121 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`: raw string/Buffer or a JSON-serializable value. */
+export type KinesisMessage = string | Buffer | Uint8Array | Record<string, unknown> | unknown[];
+/**
+ * A loosely-typed handle to an AWS v3 `KinesisClient` (or any object exposing a
+ * compatible `send(command)` method). Kept as an interface rather than the real
+ * SDK type because `@aws-sdk/client-kinesis` is loaded lazily and may not be
+ * installed at type-check time; tests inject a mock matching this shape.
+ */
+export interface KinesisClientLike {
+    send(command: unknown): Promise<any>;
+    destroy?(): void;
+}
+/** Connection options for `KinesisStore`. */
+export interface KinesisStoreOptions {
+    /** AWS region, e.g. 'us-east-1'. */
+    region?: string;
+    /** Static credentials. Omit to use the default AWS credential provider chain. */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Override the service endpoint (e.g. 'http://localhost:4566' for LocalStack). */
+    endpoint?: string;
+    /**
+     * A pre-built `KinesisClient` (or compatible object). When provided,
+     * `connect()` uses it directly and does NOT require the SDK — this is how
+     * tests inject a mock client.
+     */
+    client?: KinesisClientLike;
+}
+/** Options for `publish()`. */
+export interface PutRecordOptions {
+    /**
+     * Partition key that determines which shard the record lands on. Defaults to
+     * a generated key when omitted.
+     */
+    partitionKey?: string;
+    /** Explicit hash key (advanced shard routing). */
+    explicitHashKey?: string;
+    /** Sequence-number ordering hint. */
+    sequenceNumberForOrdering?: string;
+}
+/** Result of `publish()`. */
+export interface PutRecordResult {
+    shardId?: string;
+    sequenceNumber?: string;
+}
+/** Options for `createStream()`. */
+export interface CreateStreamOptions {
+    /** Number of shards to provision (provisioned mode). Defaults to 1. */
+    shardCount?: number;
+    /** Stream mode: 'PROVISIONED' or 'ON_DEMAND'. */
+    streamMode?: 'PROVISIONED' | 'ON_DEMAND';
+}
+/** Options for `subscribe()`. */
+export interface KinesisSubscribeOptions {
+    /** Shard to read from. Defaults to 'shardId-000000000000'. */
+    shardId?: string;
+    /**
+     * Shard-iterator type: 'LATEST' (default), 'TRIM_HORIZON',
+     * 'AT_SEQUENCE_NUMBER', 'AFTER_SEQUENCE_NUMBER', or 'AT_TIMESTAMP'.
+     */
+    shardIteratorType?: string;
+    /** Starting sequence number (for AT/AFTER_SEQUENCE_NUMBER). */
+    startingSequenceNumber?: string;
+    /** Max records per `GetRecords` call. */
+    limit?: number;
+    /** Delay between `GetRecords` polls, in ms. Defaults to 1000. */
+    pollIntervalMs?: number;
+}
+/** A handle returned by `subscribe()`; call `stop()` to end the poll loop. */
+export interface KinesisSubscription {
+    stop(): void;
+}
+/**
+ * `KinesisStore` wraps an AWS v3 `KinesisClient` and exposes stream producing,
+ * a shard-iterator consumer loop, and stream administration.
+ */
+export declare class KinesisStore implements NoSqlStore {
+    readonly name = "kinesis";
+    readonly library = "@aws-sdk/client-kinesis";
+    private readonly options;
+    private client;
+    private aws;
+    private connected;
+    /** Active subscriptions, tracked so `disconnect()` can stop their poll loops. */
+    private readonly subscriptions;
+    constructor(options?: KinesisStoreOptions);
+    connect(): Promise<void>;
+    /** Best-effort lazy-load of the SDK for its command constructors (see `command()`). */
+    private tryLoadSdk;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `KinesisClient` (loosely typed) for anything not wrapped here. */
+    getClient(): KinesisClientLike;
+    private requireClient;
+    /** Resolve a command constructor by name from the (lazily loaded) SDK. */
+    private command;
+    private wrapError;
+    /**
+     * `PutRecord` — publish one `message` to `stream`. The message is encoded to
+     * bytes (string → UTF-8, Buffer → as-is, else JSON). Returns the shard id and
+     * sequence number assigned by Kinesis.
+     */
+    publish(stream: string, message: KinesisMessage, options?: PutRecordOptions): Promise<PutRecordResult>;
+    /** `CreateStream` — provision a new stream. */
+    createStream(name: string, options?: CreateStreamOptions): Promise<void>;
+    /** Alias for `createStream()`, matching the common store surface. */
+    createTopic(name: string, options?: CreateStreamOptions): Promise<void>;
+    /**
+     * Subscribe to `stream`: acquire a shard iterator (`GetShardIterator`) and
+     * poll `GetRecords` in a loop, invoking `handler` once per record. Returns a
+     * subscription whose `stop()` ends the loop; the subscription is also tracked
+     * so `disconnect()` stops it. The poll loop runs detached (not awaited); this
+     * method resolves once the initial iterator is acquired.
+     */
+    subscribe(stream: string, handler: (record: any) => void | Promise<void>, options?: KinesisSubscribeOptions): Promise<KinesisSubscription>;
+}
+export default KinesisStore;

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

@@ -0,0 +1,112 @@
+import type { NoSqlStore } from '../store';
+import { KvDocumentLayer, type Doc, type FindOptions, type KvTransaction } from '../rocksdb/document-layer';
+import type { WhereClause } from '../rocksdb/where-match';
+export { KvDocumentLayer, KvTransaction, type Doc, type FindOptions, type IncludeSpec, } from '../rocksdb/document-layer';
+export type { WhereClause, OrderSpec } from '../rocksdb/where-match';
+/** A single entry in a `batch()` write: a `put` (with value) or a `del`. */
+export type LevelDBBatchOp = {
+    type: 'put';
+    key: string;
+    value: unknown;
+} | {
+    type: 'del';
+    key: string;
+};
+/**
+ * Minimal structural type for the pieces of a `level` client this store uses.
+ * Kept local (rather than importing from `level`) so this module type-checks
+ * without the optional driver installed.
+ */
+export interface LevelDBClientLike {
+    put(key: string, value: unknown): Promise<void>;
+    get(key: string): Promise<unknown>;
+    del(key: string): Promise<void>;
+    batch(ops: LevelDBBatchOp[]): Promise<void>;
+    iterator(options?: Record<string, unknown>): AsyncIterable<[unknown, unknown]>;
+    close(): Promise<void>;
+}
+/** Connection options for `LevelDBStore`. */
+export interface LevelDBStoreOptions {
+    /** Filesystem path for the LevelDB database directory. Defaults to `'./data/leveldb'`. */
+    path?: string;
+    /**
+     * A pre-built `level` client (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('level')` entirely — this
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: LevelDBClientLike;
+}
+/**
+ * `LevelDBStore` wraps a `level` client and exposes its embedded KV surface:
+ * `put`/`get`/`del` for single keys, `batch` for atomic multi-key writes, and
+ * `list` for ordered key iteration (optionally by prefix).
+ */
+export declare class LevelDBStore implements NoSqlStore {
+    readonly name = "leveldb";
+    readonly library = "level";
+    private readonly options;
+    private readonly path;
+    private client;
+    private connected;
+    constructor(options?: LevelDBStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `level` client for anything not wrapped here. */
+    getClient(): LevelDBClientLike;
+    private requireClient;
+    private wrapError;
+    /** Writes (or overwrites) the value at `key`. */
+    put(key: string, value: unknown): Promise<void>;
+    /** Reads the value at `key`. */
+    get(key: string): Promise<unknown>;
+    /** Deletes the value at `key`. */
+    del(key: string): Promise<void>;
+    /** Applies a list of `put`/`del` operations as a single atomic batch. */
+    batch(ops: LevelDBBatchOp[]): Promise<void>;
+    /**
+     * Lists keys in order. With `prefix`, restricts to keys `>= prefix` and
+     * `< prefix + '\xff'` (a standard prefix-scan range for byte-ordered keys).
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Ordered iteration over `[key, value]` pairs whose key is in `[gte, lt)`.
+     * Values are returned as stored (JSON strings, when written through the
+     * document layer). Used internally by the document layer's range scans.
+     */
+    scanRange(gte: string, lt: string): AsyncIterable<[string, unknown]>;
+    private docLayer;
+    private kvBackend;
+    /**
+     * Returns a document layer bound to this store, keyed by `primaryKey`
+     * (default `'id'`). Exposes the full ORM model API
+     * (`findAll`/`findOne`/`findByPk`/`create`/`bulkCreate`/`update`/`destroy`/
+     * `count`/`truncate`/`upsert`/`increment`/`transaction`).
+     */
+    documents(primaryKey?: string): KvDocumentLayer;
+    /** ORM `findAll` over a collection: where/order/limit/offset/include. */
+    findAll(collection: string, options?: FindOptions): Promise<Doc[]>;
+    /** ORM `findOne` over a collection. */
+    findOne(collection: string, options?: FindOptions): Promise<Doc | null>;
+    /** ORM `findByPk` over a collection. */
+    findByPk(collection: string, pk: unknown, options?: FindOptions): Promise<Doc | null>;
+    /** ORM `count` over a collection. */
+    count(collection: string, where?: WhereClause): Promise<number>;
+    /** ORM `create` for a single document. */
+    create(collection: string, data: Doc): Promise<Doc>;
+    /** ORM `bulkCreate` for many documents (atomic batch). */
+    bulkCreate(collection: string, rows: Doc[]): Promise<Doc[]>;
+    /** ORM `update`: merge `values` into documents matching `where`. */
+    updateWhere(collection: string, values: Doc, where?: WhereClause): Promise<number>;
+    /** ORM `destroy`: delete documents matching `where`. */
+    destroy(collection: string, where?: WhereClause): Promise<number>;
+    /** ORM `truncate`: delete every document in a collection. */
+    truncate(collection: string): Promise<number>;
+    /** Upsert a document by primary key. */
+    upsert(collection: string, data: Doc): Promise<Doc>;
+    /** Atomically increment numeric fields of one document. */
+    increment(collection: string, pk: unknown, fields: Record<string, number> | string[]): Promise<Doc | null>;
+    /** Run a function inside an atomic multi-document transaction (single batch commit). */
+    transaction<T>(fn: (tx: KvTransaction) => Promise<T>): Promise<T>;
+}
+export default LevelDBStore;

package/dist/nosql/leveldb/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LevelDBStore = void 0;
+exports.LevelDBStore = exports.KvTransaction = exports.KvDocumentLayer = void 0;
 /**
  * LevelDB store.
  *
@@ -19,6 +19,10 @@ exports.LevelDBStore = void 0;
  * tests inject a pre-built mock `client` instead and never reach the `require`.
  */
 const errors_1 = require("../../errors");
+const document_layer_1 = require("../rocksdb/document-layer");
+var document_layer_2 = require("../rocksdb/document-layer");
+Object.defineProperty(exports, "KvDocumentLayer", { enumerable: true, get: function () { return document_layer_2.KvDocumentLayer; } });
+Object.defineProperty(exports, "KvTransaction", { enumerable: true, get: function () { return document_layer_2.KvTransaction; } });
 /**
  * `LevelDBStore` wraps a `level` client and exposes its embedded KV surface:
  * `put`/`get`/`del` for single keys, `batch` for atomic multi-key writes, and
@@ -30,6 +34,16 @@ class LevelDBStore {
         this.library = 'level';
         this.client = null;
         this.connected = false;
+        // ---------------------------------------------------------------------
+        // Document / ORM model layer
+        // ---------------------------------------------------------------------
+        //
+        // These map the ORM model API onto LevelDB's KV surface (see
+        // ../rocksdb/document-layer.ts) so callers query with `where`/`order`/
+        // `limit`/`offset`/`include` instead of designing keyspaces and driving
+        // iterators by hand. `documents(primaryKey?)` picks the document field used
+        // to form keys (default `'id'`); the per-collection helpers below use `'id'`.
+        this.docLayer = null;
         this.options = options;
         this.path = options.path ?? './data/leveldb';
     }
@@ -148,6 +162,94 @@ class LevelDBStore {
             throw this.wrapError('list', err);
         }
     }
+    /**
+     * Ordered iteration over `[key, value]` pairs whose key is in `[gte, lt)`.
+     * Values are returned as stored (JSON strings, when written through the
+     * document layer). Used internally by the document layer's range scans.
+     */
+    async *scanRange(gte, lt) {
+        const client = this.requireClient();
+        try {
+            for await (const [key, value] of client.iterator({ gte, lt })) {
+                yield [String(key), value];
+            }
+        }
+        catch (err) {
+            throw this.wrapError('scanRange', err);
+        }
+    }
+    kvBackend() {
+        return {
+            get: (key) => this.get(key),
+            put: (key, value) => this.put(key, value),
+            del: (key) => this.del(key),
+            batch: (ops) => this.batch(ops),
+            scanRange: (gte, lt) => this.scanRange(gte, lt),
+        };
+    }
+    /**
+     * Returns a document layer bound to this store, keyed by `primaryKey`
+     * (default `'id'`). Exposes the full ORM model API
+     * (`findAll`/`findOne`/`findByPk`/`create`/`bulkCreate`/`update`/`destroy`/
+     * `count`/`truncate`/`upsert`/`increment`/`transaction`).
+     */
+    documents(primaryKey = 'id') {
+        if (primaryKey !== 'id') {
+            return new document_layer_1.KvDocumentLayer(this.kvBackend(), primaryKey);
+        }
+        if (!this.docLayer) {
+            this.docLayer = new document_layer_1.KvDocumentLayer(this.kvBackend(), 'id');
+        }
+        return this.docLayer;
+    }
+    /** ORM `findAll` over a collection: where/order/limit/offset/include. */
+    findAll(collection, options) {
+        return this.documents().findAll(collection, options);
+    }
+    /** ORM `findOne` over a collection. */
+    findOne(collection, options) {
+        return this.documents().findOne(collection, options);
+    }
+    /** ORM `findByPk` over a collection. */
+    findByPk(collection, pk, options) {
+        return this.documents().findByPk(collection, pk, options);
+    }
+    /** ORM `count` over a collection. */
+    count(collection, where) {
+        return this.documents().count(collection, where);
+    }
+    /** ORM `create` for a single document. */
+    create(collection, data) {
+        return this.documents().create(collection, data);
+    }
+    /** ORM `bulkCreate` for many documents (atomic batch). */
+    bulkCreate(collection, rows) {
+        return this.documents().bulkCreate(collection, rows);
+    }
+    /** ORM `update`: merge `values` into documents matching `where`. */
+    updateWhere(collection, values, where) {
+        return this.documents().update(collection, values, where);
+    }
+    /** ORM `destroy`: delete documents matching `where`. */
+    destroy(collection, where) {
+        return this.documents().destroy(collection, where);
+    }
+    /** ORM `truncate`: delete every document in a collection. */
+    truncate(collection) {
+        return this.documents().truncate(collection);
+    }
+    /** Upsert a document by primary key. */
+    upsert(collection, data) {
+        return this.documents().upsert(collection, data);
+    }
+    /** Atomically increment numeric fields of one document. */
+    increment(collection, pk, fields) {
+        return this.documents().increment(collection, pk, fields);
+    }
+    /** Run a function inside an atomic multi-document transaction (single batch commit). */
+    transaction(fn) {
+        return this.documents().transaction(fn);
+    }
 }
 exports.LevelDBStore = LevelDBStore;
 exports.default = LevelDBStore;

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

@@ -0,0 +1,76 @@
+import type { NoSqlStore } from '../store';
+/** A single entry in a `batch()` write: a `put` (with value) or a `del`. */
+export type LmdbBatchOp = {
+    type: 'put';
+    key: string;
+    value: unknown;
+} | {
+    type: 'del';
+    key: string;
+};
+/**
+ * Minimal structural type for the pieces of an `lmdb` database this store
+ * uses. Kept local (rather than importing from `lmdb`) so this module
+ * type-checks without the optional driver installed.
+ */
+export interface LmdbClientLike {
+    put(key: string, value: unknown): Promise<boolean> | boolean;
+    get(key: string): unknown;
+    remove(key: string): Promise<boolean> | boolean;
+    getRange(options?: Record<string, unknown>): Iterable<{
+        key: unknown;
+        value: unknown;
+    }>;
+    close(): Promise<void> | void;
+}
+/** Connection options for `LmdbStore`. */
+export interface LmdbStoreOptions {
+    /** Filesystem path for the LMDB environment. Defaults to `'./data/lmdb'`. */
+    path?: string;
+    /**
+     * Escape hatch for any other `lmdb` `open()` option (compression, maxDbs,
+     * encoding, ...). Merged into the object passed to `open()`.
+     */
+    config?: Record<string, unknown>;
+    /**
+     * A pre-built `lmdb` database (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('lmdb')` entirely — this
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: LmdbClientLike;
+}
+/**
+ * `LmdbStore` wraps an `lmdb` database and exposes its embedded KV surface:
+ * `put`/`get`/`del` for single keys, `batch` for multi-key writes, and `list`
+ * for ordered key range scans (optionally by prefix).
+ */
+export declare class LmdbStore implements NoSqlStore {
+    readonly name = "lmdb";
+    readonly library = "lmdb";
+    private readonly options;
+    private readonly path;
+    private client;
+    private connected;
+    constructor(options?: LmdbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `lmdb` database for anything not wrapped here. */
+    getClient(): LmdbClientLike;
+    private requireClient;
+    private wrapError;
+    /** Writes (or overwrites) the value at `key`. */
+    put(key: string, value: unknown): Promise<void>;
+    /** Reads the value at `key` (LMDB reads are synchronous; the result is returned directly). */
+    get(key: string): Promise<unknown>;
+    /** Deletes the value at `key` (LMDB `remove`). */
+    del(key: string): Promise<void>;
+    /** Applies a list of `put`/`del` operations. LMDB coalesces concurrent writes into one transaction. */
+    batch(ops: LmdbBatchOp[]): Promise<void>;
+    /**
+     * Lists keys in order via `getRange`. With `prefix`, restricts to keys
+     * `>= prefix` and `< prefix + '\xff'` (a standard prefix-scan range).
+     */
+    list(prefix?: string): Promise<string[]>;
+}
+export default LmdbStore;