ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/rocksdb/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RocksDBStore = void 0;
+exports.RocksDBStore = exports.KvTransaction = exports.KvDocumentLayer = void 0;
 /**
  * RocksDB store.
  *
@@ -19,6 +19,10 @@ exports.RocksDBStore = void 0;
  * inject a pre-built mock `client` instead and never reach the `require`.
  */
 const errors_1 = require("../../errors");
+const document_layer_1 = require("./document-layer");
+var document_layer_2 = require("./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; } });
 /**
  * `RocksDBStore` wraps a `rocksdb` client and exposes its embedded KV surface:
  * `put`/`get`/`del` for single keys, `batch` for atomic multi-key writes,
@@ -30,6 +34,16 @@ class RocksDBStore {
         this.library = 'rocksdb';
         this.client = null;
         this.connected = false;
+        // ---------------------------------------------------------------------
+        // Document / ORM model layer
+        // ---------------------------------------------------------------------
+        //
+        // These map the ORM model API onto RocksDB's KV surface (see
+        // ./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/rocksdb';
     }
@@ -147,6 +161,94 @@ class RocksDBStore {
             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.RocksDBStore = RocksDBStore;
 exports.default = RocksDBStore;

package/dist/nosql/rocksdb/where-match.d.ts

@@ -0,0 +1,21 @@
+/**
+ * In-memory evaluator for the ORM's `where` clause, plus `order` sorting.
+ *
+ * The embedded key-value stores (RocksDB, LevelDB) have no query engine, so
+ * the document layer materializes a collection via a prefix range scan and
+ * filters/sorts it here. This module understands the full standard Prorm
+ * `where` shape - both the `Op` *symbol* form (`{ age: { [Op.gt]: 18 } }`) and
+ * the equivalent `$`-string form (`{ age: { $gt: 18 } }`) produced by the
+ * `and`/`or`/`not`/`eq`/... helper functions - as well as implicit-AND plain
+ * objects (`{ status: 'active', age: 30 }`) and logical `and`/`or`/`not`
+ * groupings. Keeping this self-contained means callers never hand-write a raw
+ * iterator filter to query these stores.
+ */
+/** A where clause: plain equality object, operator object, and/or logical groups. */
+export type WhereClause = Record<string | symbol, unknown>;
+/** Order spec: a single field, a list of fields, or `[field, direction]` pairs. */
+export type OrderSpec = string | Array<string | [string, ('ASC' | 'DESC' | 'asc' | 'desc')]>;
+/** Evaluate a full where clause against a document. */
+export declare function matchWhere(doc: Record<string, unknown>, where: WhereClause): boolean;
+/** Return a new array sorted by the order spec (stable, multi-key). */
+export declare function applyOrder<T extends Record<string, unknown>>(rows: T[], order: OrderSpec): T[];

package/dist/nosql/rocksdb/where-match.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * In-memory evaluator for the ORM's `where` clause, plus `order` sorting.
+ *
+ * The embedded key-value stores (RocksDB, LevelDB) have no query engine, so
+ * the document layer materializes a collection via a prefix range scan and
+ * filters/sorts it here. This module understands the full standard Prorm
+ * `where` shape - both the `Op` *symbol* form (`{ age: { [Op.gt]: 18 } }`) and
+ * the equivalent `$`-string form (`{ age: { $gt: 18 } }`) produced by the
+ * `and`/`or`/`not`/`eq`/... helper functions - as well as implicit-AND plain
+ * objects (`{ status: 'active', age: 30 }`) and logical `and`/`or`/`not`
+ * groupings. Keeping this self-contained means callers never hand-write a raw
+ * iterator filter to query these stores.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchWhere = matchWhere;
+exports.applyOrder = applyOrder;
+/** Canonical operator name for a where-clause key, whether symbol or `$string`. */
+function opName(key) {
+    if (typeof key === 'symbol') {
+        // Symbol descriptions look like `Symbol(gt)` -> description is `gt`.
+        return key.description ?? '';
+    }
+    // Strip a leading `$` from string operator keys (`$gt` -> `gt`).
+    return key.startsWith('$') ? key.slice(1) : key;
+}
+const LOGICAL = new Set(['and', 'or', 'not']);
+/** Read a possibly dotted path (`a.b.c`) out of a document. */
+function getPath(doc, path) {
+    if (doc == null)
+        return undefined;
+    if (!path.includes('.'))
+        return doc[path];
+    let cur = doc;
+    for (const part of path.split('.')) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        return ka.length === kb.length && ka.every((k) => deepEqual(a[k], b[k]));
+    }
+    return false;
+}
+/** Comparable ordering for `<`/`>` operators, coercing Dates to their epoch. */
+function cmp(a, b) {
+    const av = a instanceof Date ? a.getTime() : a;
+    const bv = b instanceof Date ? b.getTime() : b;
+    if (av < bv)
+        return -1;
+    if (av > bv)
+        return 1;
+    return 0;
+}
+/** Translate a SQL LIKE pattern (`%`, `_`) into an anchored RegExp. */
+function likeToRegExp(pattern, flags) {
+    let out = '';
+    for (const ch of pattern) {
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${out}$`, flags);
+}
+/** Evaluate a single operator against an actual field value. */
+function evalOperator(op, actual, operand) {
+    switch (op) {
+        case 'eq':
+        case 'is':
+            return deepEqual(actual, operand);
+        case 'ne':
+            return !deepEqual(actual, operand);
+        case 'gt':
+            return actual != null && operand != null && cmp(actual, operand) > 0;
+        case 'gte':
+            return actual != null && operand != null && cmp(actual, operand) >= 0;
+        case 'lt':
+            return actual != null && operand != null && cmp(actual, operand) < 0;
+        case 'lte':
+            return actual != null && operand != null && cmp(actual, operand) <= 0;
+        case 'in':
+            return Array.isArray(operand) && operand.some((v) => deepEqual(actual, v));
+        case 'notIn':
+            return Array.isArray(operand) && !operand.some((v) => deepEqual(actual, v));
+        case 'between':
+            return (Array.isArray(operand) && cmp(actual, operand[0]) >= 0 && cmp(actual, operand[1]) <= 0);
+        case 'notBetween':
+            return (Array.isArray(operand) && !(cmp(actual, operand[0]) >= 0 && cmp(actual, operand[1]) <= 0));
+        case 'isNull':
+            // `{ field: { [Op.isNull]: true } }` or `false` to invert.
+            return operand === false ? actual != null : actual == null;
+        case 'isNotNull':
+            return operand === false ? actual == null : actual != null;
+        case 'like':
+        case 'notLike': {
+            const ok = typeof actual === 'string' && likeToRegExp(String(operand), '').test(actual);
+            return op === 'like' ? ok : !ok;
+        }
+        case 'iLike':
+        case 'notILike': {
+            const ok = typeof actual === 'string' && likeToRegExp(String(operand), 'i').test(actual);
+            return op === 'iLike' ? ok : !ok;
+        }
+        case 'startsWith':
+        case 'notStartsWith': {
+            const ok = typeof actual === 'string' && actual.startsWith(String(operand));
+            return op === 'startsWith' ? ok : !ok;
+        }
+        case 'endsWith':
+        case 'notEndsWith': {
+            const ok = typeof actual === 'string' && actual.endsWith(String(operand));
+            return op === 'endsWith' ? ok : !ok;
+        }
+        case 'substring':
+        case 'notSubstring': {
+            const ok = typeof actual === 'string' && actual.includes(String(operand));
+            return op === 'substring' ? ok : !ok;
+        }
+        case 'regexp':
+        case 'notRegexp': {
+            const ok = typeof actual === 'string' && new RegExp(String(operand)).test(actual);
+            return op === 'regexp' ? ok : !ok;
+        }
+        case 'iRegexp':
+        case 'notIRegexp': {
+            const ok = typeof actual === 'string' && new RegExp(String(operand), 'i').test(actual);
+            return op === 'iRegexp' ? ok : !ok;
+        }
+        case 'contains': {
+            // Array containment: actual (array) contains all operand elements.
+            if (!Array.isArray(actual))
+                return false;
+            const ops = Array.isArray(operand) ? operand : [operand];
+            return ops.every((v) => actual.some((a) => deepEqual(a, v)));
+        }
+        case 'arrayContains':
+            return (Array.isArray(actual) &&
+                Array.isArray(operand) &&
+                operand.every((v) => actual.some((a) => deepEqual(a, v))));
+        case 'arrayContainedBy':
+            return (Array.isArray(actual) &&
+                Array.isArray(operand) &&
+                actual.every((a) => operand.some((v) => deepEqual(a, v))));
+        case 'arrayOverlaps':
+            return (Array.isArray(actual) &&
+                Array.isArray(operand) &&
+                actual.some((a) => operand.some((v) => deepEqual(a, v))));
+        default:
+            throw new Error(`Unsupported where operator "${op}" in embedded KV query`);
+    }
+}
+/** Match a single field's value against a condition (equality or operator map). */
+function matchField(actual, condition) {
+    if (condition === null)
+        return actual == null;
+    if (typeof condition !== 'object' ||
+        condition instanceof Date ||
+        Array.isArray(condition)) {
+        // Bare value -> equality.
+        return deepEqual(actual, condition);
+    }
+    // Operator map: every operator must hold (implicit AND).
+    const keys = Reflect.ownKeys(condition);
+    if (keys.length === 0)
+        return true;
+    return keys.every((k) => {
+        const op = opName(k);
+        const operand = condition[k];
+        if (LOGICAL.has(op)) {
+            // Nested logical operator on a field value is rare but supported.
+            return matchField(actual, { [k]: operand });
+        }
+        return evalOperator(op, actual, operand);
+    });
+}
+/** Evaluate a full where clause against a document. */
+function matchWhere(doc, where) {
+    const keys = Reflect.ownKeys(where);
+    return keys.every((key) => {
+        const op = opName(key);
+        const value = where[key];
+        if (op === 'and') {
+            const arr = Array.isArray(value) ? value : [value];
+            return arr.every((sub) => matchWhere(doc, sub));
+        }
+        if (op === 'or') {
+            const arr = Array.isArray(value) ? value : [value];
+            return arr.some((sub) => matchWhere(doc, sub));
+        }
+        if (op === 'not') {
+            const arr = Array.isArray(value) ? value : [value];
+            return !arr.some((sub) => matchWhere(doc, sub));
+        }
+        // Otherwise `key` is a field name (symbol keys only ever encode operators,
+        // so a symbol here that is not logical is an operator with no field - skip).
+        if (typeof key === 'symbol')
+            return true;
+        return matchField(getPath(doc, key), value);
+    });
+}
+/** Normalize an `order` spec into `[field, ascending]` tuples. */
+function normalizeOrder(order) {
+    if (typeof order === 'string')
+        return [[order, true]];
+    return order.map((entry) => {
+        if (typeof entry === 'string')
+            return [entry, true];
+        const [field, dir] = entry;
+        return [field, String(dir).toUpperCase() !== 'DESC'];
+    });
+}
+/** Return a new array sorted by the order spec (stable, multi-key). */
+function applyOrder(rows, order) {
+    const keys = normalizeOrder(order);
+    return [...rows].sort((a, b) => {
+        for (const [field, asc] of keys) {
+            const c = cmp(getPath(a, field), getPath(b, field));
+            if (c !== 0)
+                return asc ? c : -c;
+        }
+        return 0;
+    });
+}

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

@@ -0,0 +1,84 @@
+/**
+ * Rockset store.
+ *
+ * Rockset is a real-time analytics database that indexes streaming and
+ * document data (a "converged index" over row, columnar, and inverted
+ * indexes) and serves low-latency SQL over it. It is a schemaless,
+ * document-oriented, HTTP/JSON service with an official client
+ * (`@rockset/client`); there is no relational connection, no server-side
+ * transactions, and ingestion is document-based (`addDocuments`), so it does
+ * not fit the SQL-shaped `Dialect` interface (`src/dialects/dialect.ts`).
+ * This class implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes Rockset's query + document API directly.
+ *
+ * ## Driver: `@rockset/client`
+ *
+ * The `@rockset/client` package is an optional peer dependency, lazily
+ * `require`d inside `connect()` so importing this module never forces it to be
+ * installed. Tests inject a pre-built mock client via `RocksetStoreOptions.client`,
+ * which skips the `require` entirely.
+ */
+import type { NoSqlStore } from '../store';
+/**
+ * Minimal structural type for the pieces of a `@rockset/client` instance this
+ * store uses. Kept local so this module type-checks without the optional
+ * driver installed.
+ */
+export interface RocksetClientLike {
+    queries: {
+        query(request: {
+            sql: {
+                query: string;
+                parameters?: unknown[];
+            };
+        }): Promise<any>;
+    };
+    documents: {
+        addDocuments(workspace: string, collection: string, request: {
+            data: unknown[];
+        }): Promise<any>;
+    };
+}
+/** Connection options for `RocksetStore`. */
+export interface RocksetStoreOptions {
+    /** Rockset API key used to authenticate the client. */
+    apiKey?: string;
+    /** Rockset API server host, e.g. `https://api.usw2a1.rockset.com`. */
+    host?: string;
+    /**
+     * A pre-built `@rockset/client` instance (or compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('@rockset/client')`. This
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: RocksetClientLike;
+}
+/**
+ * `RocksetStore` wraps a `@rockset/client` instance and exposes SQL querying
+ * (`query`) plus document ingestion (`ingest`) into a `workspace.collection`.
+ */
+export declare class RocksetStore implements NoSqlStore {
+    readonly name = "rockset";
+    readonly library = "@rockset/client";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: RocksetStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `@rockset/client` instance for anything not wrapped here. */
+    getClient(): RocksetClientLike;
+    private requireClient;
+    /**
+     * Run a SQL query via `client.queries.query({ sql: { query, parameters } })`
+     * and return the `results` array from the response.
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Ingest `docs` into `target` (a `workspace.collection` path, or just a
+     * collection name — defaulting the workspace to `commons`) via
+     * `client.documents.addDocuments(workspace, collection, { data })`.
+     */
+    ingest(target: string, docs: Array<Record<string, unknown>>): Promise<any>;
+}
+export default RocksetStore;

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

@@ -0,0 +1,170 @@
+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 S3ClientLike {
+    send(command: unknown): Promise<any>;
+    destroy?(): void;
+}
+/** Connection options for `S3Store`. */
+export interface S3StoreOptions {
+    /** AWS region, e.g. 'us-east-1'. */
+    region?: string;
+    /** Static credentials. Omit to fall back to the default AWS credential provider chain. */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /**
+     * Override the service endpoint, e.g. 'http://localhost:9000' for a
+     * MinIO / LocalStack S3-compatible server. When set, region and
+     * credentials can be dummy values for servers that don't validate them.
+     */
+    endpoint?: string;
+    /**
+     * Use path-style bucket addressing (`endpoint/bucket/key`) instead of
+     * virtual-hosted-style (`bucket.endpoint/key`). Usually required for
+     * MinIO / LocalStack and other S3-compatible servers.
+     */
+    forcePathStyle?: boolean;
+    /**
+     * 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` from the
+     * options above.
+     */
+    client?: S3ClientLike;
+}
+/** 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;
+    /** Canned ACL, e.g. 'private', 'public-read'. */
+    acl?: string;
+    /** Server-side encryption algorithm, e.g. 'AES256', 'aws:kms'. */
+    serverSideEncryption?: 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 S3ObjectSummary {
+    key?: string;
+    size?: number;
+    etag?: string;
+    lastModified?: Date;
+}
+/** Result of `listObjects()`. */
+export interface ListObjectsResult {
+    objects: S3ObjectSummary[];
+    /** 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;
+}
+/** Result of `copyObject()`. */
+export interface CopyObjectResult {
+    etag?: string;
+    lastModified?: Date;
+}
+/**
+ * Amazon S3 store, implementing the minimal `NoSqlStore` marker interface.
+ * Unlike the SQL dialects, there is no `query(sql)` — S3's operations are
+ * object-shaped (Put/Get/Delete/List/Head/Copy) and that shape is preserved
+ * here rather than forced into a SQL string.
+ */
+export declare class S3Store implements NoSqlStore {
+    readonly name = "s3";
+    readonly library = "@aws-sdk/client-s3";
+    private readonly options;
+    private client;
+    private aws;
+    private connected;
+    constructor(options?: S3StoreOptions);
+    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(): S3ClientLike;
+    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 S3 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>;
+    /** `CopyObject` — server-side copy from `srcBucket`/`srcKey` to `destBucket`/`destKey`. */
+    copyObject(srcBucket: string, srcKey: string, destBucket: string, destKey: string): Promise<CopyObjectResult>;
+    /**
+     * Recognize S3's "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 S3Store;