ts-prorm-orm 1.1.0 → 1.2.1

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

@@ -0,0 +1,116 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`: raw string/Buffer or a JSON-serializable value. */
+export type SqsMessage = string | Buffer | Record<string, unknown> | unknown[];
+/**
+ * A loosely-typed handle to an AWS v3 `SQSClient` (or any object exposing a
+ * compatible `send(command)` method). Tests inject a mock matching this shape.
+ */
+export interface SqsClientLike {
+    send(command: unknown): Promise<any>;
+    destroy?(): void;
+}
+/** Connection options for `SqsStore`. */
+export interface SqsStoreOptions {
+    /** 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 `SQSClient` (or compatible object). When provided, `connect()`
+     * uses it directly and does NOT require the SDK — this is how tests inject a
+     * mock client.
+     */
+    client?: SqsClientLike;
+}
+/** Options for `publish()` (`SendMessage`). */
+export interface SendMessageOptions {
+    /** Delay before the message becomes visible, in seconds. */
+    delaySeconds?: number;
+    /** FIFO group id (required for FIFO queues). */
+    messageGroupId?: string;
+    /** FIFO dedupe id. */
+    messageDeduplicationId?: string;
+    /** Message attributes, passed straight through. */
+    messageAttributes?: Record<string, unknown>;
+}
+/** Result of `publish()`. */
+export interface SendMessageResult {
+    messageId?: string;
+    sequenceNumber?: string;
+}
+/** Options for `createQueue()`. */
+export interface CreateQueueOptions {
+    /** Queue attributes (e.g. `{ FifoQueue: 'true' }`), passed straight through. */
+    attributes?: Record<string, string>;
+    /** Cost-allocation / metadata tags. */
+    tags?: Record<string, string>;
+}
+/** Options for `subscribe()`. */
+export interface SqsSubscribeOptions {
+    /** Max messages per `ReceiveMessage` call (1-10). Defaults to 10. */
+    maxMessages?: number;
+    /** Long-poll wait time, in seconds (0-20). Defaults to 20. */
+    waitTimeSeconds?: number;
+    /** Visibility timeout for received messages, in seconds. */
+    visibilityTimeout?: number;
+    /**
+     * Delete (ack) each message after the handler resolves. Defaults to true;
+     * set false to leave deletion to the handler (at-least-once redelivery).
+     */
+    autoDelete?: boolean;
+    /** Delay between empty polls, in ms. Defaults to 0 (SQS long-polling already waits). */
+    pollIntervalMs?: number;
+}
+/** A handle returned by `subscribe()`; call `stop()` to end the receive loop. */
+export interface SqsSubscription {
+    stop(): void;
+}
+/**
+ * `SqsStore` wraps an AWS v3 `SQSClient` and exposes queue sending, a
+ * receive-and-ack poll loop, and queue administration.
+ */
+export declare class SqsStore implements NoSqlStore {
+    readonly name = "sqs";
+    readonly library = "@aws-sdk/client-sqs";
+    private readonly options;
+    private client;
+    private aws;
+    private connected;
+    /** Active subscriptions, tracked so `disconnect()` stops their receive loops. */
+    private readonly subscriptions;
+    constructor(options?: SqsStoreOptions);
+    connect(): Promise<void>;
+    private tryLoadSdk;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `SQSClient` (loosely typed) for anything not wrapped here. */
+    getClient(): SqsClientLike;
+    private requireClient;
+    private command;
+    private wrapError;
+    /**
+     * `SendMessage` — publish one `message` to the queue at `queueUrl`. The
+     * message is encoded to a string body (string as-is, Buffer → UTF-8, else
+     * JSON). Returns the message id (and FIFO sequence number, if any).
+     */
+    publish(queueUrl: string, message: SqsMessage, options?: SendMessageOptions): Promise<SendMessageResult>;
+    /** `CreateQueue` — create a queue by name. Returns its URL. */
+    createQueue(name: string, options?: CreateQueueOptions): Promise<string | undefined>;
+    /** Alias for `createQueue()`, matching the common store surface. */
+    createTopic(name: string, options?: CreateQueueOptions): Promise<string | undefined>;
+    /**
+     * Subscribe to the queue at `queueUrl`: long-poll `ReceiveMessage` in a loop,
+     * invoke `handler` once per message, and (by default) `DeleteMessage` to ack
+     * each message after the handler resolves. Returns a subscription whose
+     * `stop()` ends the loop; the subscription is tracked so `disconnect()` stops
+     * it. The loop runs detached (not awaited); this method resolves immediately.
+     */
+    subscribe(queueUrl: string, handler: (message: any) => void | Promise<void>, options?: SqsSubscribeOptions): SqsSubscription;
+}
+export default SqsStore;

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

@@ -0,0 +1,86 @@
+/**
+ * Stardog store implementation.
+ *
+ * Stardog is an enterprise knowledge-graph / RDF triplestore. It speaks the
+ * SPARQL 1.1 Protocol over HTTP: a database exposes a query endpoint
+ * (`/<db>/query`) and an update endpoint (`/<db>/update`). There is no
+ * SQL-shaped surface, so it implements the minimal `NoSqlStore` marker
+ * interface (`src/nosql/store.ts`) rather than the SQL `Dialect` interface.
+ *
+ * ## Driver strategy - prefer HTTP over `fetch`
+ *
+ * Stardog publishes a `stardog` npm client, but this store prefers the plain
+ * SPARQL/HTTP protocol over the global `fetch` so it has no hard dependency
+ * (`library='fetch'`). For tests (and for callers who want their own
+ * transport) an alternative client can be injected via
+ * `StardogStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `endpoint` is built at connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/<db>/query`, returns bindings
+ * - `update(sparql)` -> POST to `/<db>/update`
+ * - `ask(sparql)`    -> POST an ASK query, returns the boolean
+ * - `add(triples)`   -> `INSERT DATA { ... }` update
+ * - `drop(graph?)`   -> `DROP GRAPH <g>` / `DROP ALL` update
+ */
+import { NoSqlStore } from '../store';
+/** Default Stardog base URL. */
+export declare const DEFAULT_STARDOG_ENDPOINT = "http://localhost:5820";
+/** Default database name. */
+export declare const DEFAULT_STARDOG_DATABASE = "db";
+/** The subset of a SPARQL HTTP client this store needs. */
+export interface SparqlHttpClient {
+    /** POST a SPARQL query to `path`; returns the parsed results envelope. */
+    query(path: string, sparql: string): Promise<any>;
+    /** POST a SPARQL update to `path`. */
+    update(path: string, sparql: string): Promise<any>;
+}
+/** Connection options for `StardogStore`. */
+export interface StardogStoreOptions {
+    /** Base URL of the Stardog server. Defaults to `http://localhost:5820`. */
+    endpoint?: string;
+    /** Database name. Defaults to `db`. */
+    database?: string;
+    /** Optional pre-built SPARQL HTTP client (used verbatim; `endpoint` ignored). */
+    client?: SparqlHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed SPARQL client for the given endpoint. */
+export declare function createFetchClient(endpoint: string, headers?: Record<string, string>): SparqlHttpClient;
+/**
+ * `StardogStore` wraps a Stardog database's SPARQL query/update endpoints
+ * behind the `NoSqlStore` lifecycle.
+ */
+export declare class StardogStore implements NoSqlStore {
+    readonly name = "stardog";
+    readonly library = "fetch";
+    private readonly endpoint;
+    private readonly database;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: StardogStoreOptions);
+    /** SPARQL query endpoint path for the configured database. */
+    get queryPath(): string;
+    /** SPARQL update endpoint path for the configured database. */
+    get updatePath(): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) SPARQL HTTP client. */
+    getClient(): SparqlHttpClient;
+    private requireClient;
+    /** Runs a SPARQL SELECT/CONSTRUCT query; returns the result bindings. */
+    query(sparql: string): Promise<any[]>;
+    /** Runs a SPARQL ASK query; returns the boolean answer. */
+    ask(sparql: string): Promise<boolean>;
+    /** Runs a SPARQL UPDATE (INSERT/DELETE/DROP/...). */
+    update(sparql: string): Promise<any>;
+    /** Inserts triples via `INSERT DATA { ... }`. Accepts a triple string or array. */
+    add(triples: string | string[], graph?: string): Promise<any>;
+    /** Drops a named graph, or all graphs when no graph is given. */
+    drop(graph?: string): Promise<any>;
+}

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

@@ -0,0 +1,89 @@
+/**
+ * StarRocks store.
+ *
+ * StarRocks is a high-performance real-time analytical (MPP OLAP) database.
+ * Crucially it speaks the **MySQL wire protocol**, so it is queried with the
+ * `mysql2` driver over a normal MySQL connection/pool. Despite the MySQL
+ * wire, StarRocks is a columnar analytics engine (no OLTP transactions, no
+ * row-level UPDATE/DELETE in the usual sense on most table types), which does
+ * not fit this ORM's SQL `Dialect` abstraction cleanly, so it is modelled as
+ * a `NoSqlStore` (`src/nosql/store.ts`) exposing a direct `query`/`ingest`
+ * surface.
+ *
+ * ## Driver: `mysql2` (MySQL-wire)
+ *
+ * The `mysql2` 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 connection via
+ * `StarrocksStoreOptions.client`, which skips the `require` entirely.
+ *
+ * ## Ingestion
+ *
+ * `ingest()` here performs a batched `INSERT` over the MySQL wire, which is
+ * convenient for small/medium loads. For high-throughput loading StarRocks
+ * also offers **Stream Load** (an HTTP `PUT /api/{db}/{table}/_stream_load`
+ * endpoint). Stream Load is intentionally *not* wired here (it is a separate
+ * HTTP transport, optional); use the `mysql2`-based `ingest()` for wire-level
+ * inserts, or POST to the Stream Load endpoint yourself for bulk pipelines.
+ */
+import type { NoSqlStore } from '../store';
+/**
+ * Minimal structural type for the pieces of a `mysql2/promise` connection (or
+ * pool) this store uses. Kept local so this module type-checks without the
+ * optional driver installed. `query()` resolves to `[rows, fields]`.
+ */
+export interface MysqlConnectionLike {
+    query(sql: string, params?: unknown[]): Promise<[any, any]>;
+    end?(): Promise<void>;
+}
+/** Connection options for `StarrocksStore` (map onto `mysql2` connection config). */
+export interface StarrocksStoreOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    /** Escape hatch for any other `mysql2` connection option. */
+    connectionOptions?: Record<string, unknown>;
+    /**
+     * A pre-built `mysql2` connection/pool (or compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('mysql2/promise')`. This
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: MysqlConnectionLike;
+}
+/**
+ * `StarrocksStore` wraps a `mysql2` connection to a StarRocks frontend and
+ * exposes `query(sql, params)` for reads/DDL and `ingest(table, rows)` for
+ * batched wire-level inserts.
+ */
+export declare class StarrocksStore implements NoSqlStore {
+    readonly name = "starrocks";
+    readonly library = "mysql2";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: StarrocksStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `mysql2` connection for anything not wrapped here. */
+    getClient(): MysqlConnectionLike;
+    private requireClient;
+    /**
+     * Execute a SQL statement over the MySQL wire with optional positional
+     * `params` and return the result rows (the first element of `mysql2`'s
+     * `[rows, fields]` tuple).
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Batch-insert `rows` into `table` via a single parameterized
+     * `INSERT INTO table (cols) VALUES (...)` over the MySQL wire. Columns are
+     * taken from the first row. Returns the driver result (`OkPacket`).
+     *
+     * For high-throughput bulk loading, use StarRocks Stream Load (HTTP) instead
+     * — see the module header.
+     */
+    ingest(table: string, rows: Array<Record<string, unknown>>): Promise<any>;
+}
+export default StarrocksStore;

package/dist/nosql/store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Base interface for NoSQL stores.
+ *
+ * NoSQL engines (document stores, key-value caches, partition-key stores)
+ * do not share the SQL-shaped `Dialect` interface (no `query(sql)`, no
+ * identifier escaping, no DDL). `NoSqlStore` is intentionally minimal:
+ * connection lifecycle plus a `raw` escape hatch. Each store's real API
+ * surface (find/insert/update for Mongo, hash/list/set ops for Redis,
+ * item CRUD for DynamoDB) lives on its own class, not on this interface,
+ * because forcing them into one shared query shape would misrepresent
+ * what each engine can actually do.
+ */
+export interface NoSqlStore {
+    /** The name of the store (e.g. 'mongodb', 'redis', 'dynamodb') */
+    readonly name: string;
+    /** The client library being used */
+    readonly library: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Access the underlying native client for operations not wrapped here */
+    getClient(): unknown;
+}

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

@@ -0,0 +1,119 @@
+/**
+ * Sumo Logic store implementation.
+ *
+ * Sumo Logic is a cloud log-management and analytics platform. Logs are
+ * ingested by POSTing to an HTTP Source collector URL, and searched with the
+ * Search Job API (create a job, then poll for status/messages). There is no
+ * SQL-shaped query surface, no row-level UPDATE/DELETE, and no identifier
+ * escaping, so Sumo Logic does not fit the SQL `Dialect` interface
+ * (`src/dialects/dialect.ts`). This class implements the minimal
+ * `NoSqlStore` marker interface (`src/nosql/store.ts`) and exposes Sumo's
+ * ingest/search API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Sumo Logic has no single canonical npm client; it is an HTTP/JSON API.
+ * This store talks to it with the global `fetch` (so `library` is
+ * `'fetch'`). For tests (and custom transports) an alternative HTTP client
+ * can be injected via `SumoLogicStoreOptions.client`.
+ *
+ * Ingest and search live on different hosts: ingest targets the per-source
+ * `collectorURL`, while search targets the regional `apiURL`. The internal
+ * client resolves absolute URLs verbatim, so `push()` posts to the full
+ * collector URL while the search/metadata methods use relative API paths.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(lines)`     -> `POST <collectorURL>`             (HTTP Source ingest)
+ * - `query(q, opts?)` -> `POST /api/v1/search/jobs`         (create search job)
+ * - `messages(id)`    -> `GET  /api/v1/search/jobs/<id>/messages`
+ * - `labels()`        -> `GET  /api/v1/fields`              (field names)
+ * - `streams()`       -> `GET  /api/v1/collectors`          (collectors)
+ */
+import { NoSqlStore } from '../store';
+/** Default Sumo Logic API base URL. */
+export declare const DEFAULT_SUMOLOGIC_API_URL = "https://api.sumologic.com";
+/** Query-string parameter value(s). `undefined` values are dropped. */
+export type QueryParams = Record<string, string | string[] | undefined>;
+/**
+ * The subset of an HTTP client this store needs. The internal `fetch`-based
+ * client implements this; tests inject a mock with the same shape.
+ */
+export interface SumoLogicHttpClient {
+    /** Issue a GET and return the parsed JSON response body. */
+    get(path: string, params?: QueryParams): Promise<any>;
+    /** Issue a POST with a text body and return the parsed JSON/text response. */
+    post(path: string, body: string, contentType?: string): Promise<any>;
+}
+/** Connection options for `SumoLogicStore`. */
+export interface SumoLogicStoreOptions {
+    /** Base URL for the Search Job / metadata API. Defaults to `https://api.sumologic.com`. */
+    apiURL?: string;
+    /** Full HTTP Source collector URL that `push()` ingests to. */
+    collectorURL?: string;
+    /**
+     * Optional pre-built HTTP client. When provided it is used verbatim and
+     * `apiURL` is ignored; otherwise an internal `fetch`-based client is
+     * built against `apiURL` on `connect()`.
+     */
+    client?: SumoLogicHttpClient;
+    /** Extra HTTP headers (e.g. basic-auth `Authorization`) sent with every request. */
+    headers?: Record<string, string>;
+}
+/** Options for creating a search job. */
+export interface SumoLogicQueryOptions {
+    /** Start of the search window (ISO 8601 or epoch ms). */
+    from?: string | number;
+    /** End of the search window (ISO 8601 or epoch ms). */
+    to?: string | number;
+    /** Time zone for relative expressions (e.g. `UTC`). */
+    timeZone?: string;
+    /** Whether the query is by receipt time rather than message time. */
+    byReceiptTime?: boolean;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): SumoLogicHttpClient;
+/**
+ * `SumoLogicStore` wraps Sumo Logic's HTTP Source ingest and its Search Job
+ * API (create job + fetch messages) plus field/collector metadata behind the
+ * `NoSqlStore` lifecycle.
+ */
+export declare class SumoLogicStore implements NoSqlStore {
+    readonly name = "sumologic";
+    readonly library = "fetch";
+    private readonly apiURL;
+    private readonly collectorURL?;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: SumoLogicStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): SumoLogicHttpClient;
+    private requireClient;
+    private doGet;
+    /**
+     * Ingests raw log lines by POSTing them (newline-delimited) to the
+     * configured HTTP Source `collectorURL`. Accepts a single string or an
+     * array of lines (joined with newlines).
+     */
+    push(lines: string | string[]): Promise<any>;
+    /**
+     * Creates a search job via `POST /api/v1/search/jobs`. Returns the parsed
+     * response (typically `{ id }`); use `messages(id)` to fetch results once
+     * the job completes.
+     */
+    query(q: string, options?: SumoLogicQueryOptions): Promise<any>;
+    /** Fetches messages for a completed search job via `GET /api/v1/search/jobs/<id>/messages`. */
+    messages(jobId: string, offset?: number, limit?: number): Promise<any>;
+    /** Fetches the status of a search job via `GET /api/v1/search/jobs/<id>`. */
+    jobStatus(jobId: string): Promise<any>;
+    /** Lists the configured fields via `GET /api/v1/fields`. */
+    labels(): Promise<any>;
+    /** Lists the collectors via `GET /api/v1/collectors`. */
+    streams(): Promise<any>;
+}
+export default SumoLogicStore;

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

@@ -0,0 +1,156 @@
+/**
+ * SurrealDB store implementation for the Prorm NoSQL layer.
+ *
+ * SurrealDB is a multi-model database with its own record/graph model and
+ * the SurrealQL query language, so it does not fit the SQL-shaped `Dialect`
+ * interface (no identifier escaping, no SQL DDL). This class implements the
+ * minimal `NoSqlStore` marker interface for connection lifecycle and
+ * otherwise exposes SurrealDB's real API surface directly: record CRUD over
+ * "things" (table or `table:id` record identifiers) plus raw SurrealQL via
+ * `query()`.
+ *
+ * Uses the `surrealdb` driver. The driver is loaded lazily inside
+ * `connect()` (via `require`) so importing this module never forces the
+ * optional `surrealdb` dependency to be installed. For testing (or to reuse
+ * an already-configured connection) a pre-built `Surreal` instance can be
+ * injected through {@link SurrealStoreOptions.client}, in which case the
+ * `require` is skipped entirely.
+ */
+import { NoSqlStore } from '../store';
+import { type WhereClause, type OrderSpec } from '../rocksdb/where-match';
+export { compileWhere, compileOrder, PushdownUnsupported } from './query-compiler';
+export type { WhereClause, OrderSpec } from '../rocksdb/where-match';
+/** Options for {@link SurrealStore.findAll} / {@link SurrealStore.findOne}. */
+export interface SurrealFindOptions {
+    where?: WhereClause;
+    order?: OrderSpec;
+    limit?: number;
+    offset?: number;
+    /** SurrealQL `FETCH` targets - dereference record links/graph edges inline. */
+    fetch?: string[];
+}
+/**
+ * Connection options for `SurrealStore`.
+ *
+ * `url` is the SurrealDB endpoint (e.g. `ws://127.0.0.1:8000/rpc` or
+ * `http://127.0.0.1:8000`). `namespace`/`database` select the namespace and
+ * database to `use()` after connecting. `username`/`password` are the root
+ * (or scoped) credentials used to `signin()`. A pre-built `Surreal` client
+ * can be supplied via `client` to bypass the lazy `require('surrealdb')`.
+ */
+export interface SurrealStoreOptions {
+    /** SurrealDB endpoint URL, e.g. `ws://127.0.0.1:8000/rpc`. */
+    url: string;
+    /** Namespace to `use()` after connecting. */
+    namespace?: string;
+    /** Database to `use()` after connecting. */
+    database?: string;
+    /** Username for `signin()`. */
+    username?: string;
+    /** Password for `signin()`. */
+    password?: string;
+    /**
+     * A pre-built `Surreal` instance. When provided, `connect()` uses it
+     * directly (still calling `signin()`/`use()` when credentials/ns/db are
+     * configured) and skips `require('surrealdb')`. Primarily for tests and
+     * connection reuse.
+     */
+    client?: any;
+}
+/**
+ * A SurrealDB "thing": either a table name (`'user'`) to operate on every
+ * record in the table, or a specific record id (`'user:jane'`).
+ */
+export type Thing = string;
+/**
+ * `SurrealStore` wraps the `surrealdb` driver's `Surreal` client, exposing
+ * record CRUD (`create`/`select`/`update`/`merge`/`delete`) and raw
+ * SurrealQL (`query`) as a small promise-based API.
+ */
+export declare class SurrealStore implements NoSqlStore {
+    readonly name = "surrealdb";
+    readonly library = "surrealdb";
+    private readonly options;
+    private db;
+    private connected;
+    constructor(options: SurrealStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying native `Surreal` client. */
+    getClient(): any;
+    private requireClient;
+    private exec;
+    /**
+     * Create a record. `thing` may be a table name (`'user'`, id auto-
+     * generated) or a specific record id (`'user:jane'`). Passthrough to the
+     * driver's `Surreal.create()`.
+     */
+    create<T = unknown>(thing: Thing, data?: Record<string, unknown>): Promise<T>;
+    /**
+     * Select a record or all records in a table. Passthrough to the driver's
+     * `Surreal.select()`.
+     */
+    select<T = unknown>(thing: Thing): Promise<T>;
+    /**
+     * Replace the content of a record (or every record in a table).
+     * Passthrough to the driver's `Surreal.update()`.
+     */
+    update<T = unknown>(thing: Thing, data?: Record<string, unknown>): Promise<T>;
+    /**
+     * Merge the given data into a record (or every record in a table),
+     * leaving unspecified fields intact. Passthrough to the driver's
+     * `Surreal.merge()`.
+     */
+    merge<T = unknown>(thing: Thing, data?: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete a record (or every record in a table). Passthrough to the
+     * driver's `Surreal.delete()`.
+     */
+    delete<T = unknown>(thing: Thing): Promise<T>;
+    /**
+     * Run a raw SurrealQL statement (or several `;`-separated statements),
+     * optionally binding `vars` as `$name` parameters. Returns the driver's
+     * result array (one entry per statement). Passthrough to the driver's
+     * `Surreal.query()`.
+     */
+    query<T = unknown[]>(surql: string, vars?: Record<string, unknown>): Promise<T>;
+    /** Unwrap the driver's per-statement query result into a row array. */
+    private static rows;
+    /**
+     * ORM `findAll`. Compiles `where`/`order`/`limit`/`offset` to a bound
+     * SurrealQL `SELECT`; on an un-pushable operator it selects the table and
+     * filters/sorts/paginates client-side, so the result is always correct.
+     */
+    findAll<T = Record<string, unknown>>(table: string, options?: SurrealFindOptions): Promise<T[]>;
+    /** Client-side fallback: fetch the table, then filter/sort/page in memory. */
+    private findAllClientSide;
+    /** ORM `findOne`: the first row matching `where` (respecting order). */
+    findOne<T = Record<string, unknown>>(table: string, options?: SurrealFindOptions): Promise<T | null>;
+    /** ORM `findByPk`: select a single `table:id` record, or `null`. */
+    findByPk<T = Record<string, unknown>>(table: string, id: unknown): Promise<T | null>;
+    /** ORM `count`: number of records matching `where`. */
+    count(table: string, where?: WhereClause): Promise<number>;
+    /** ORM `bulkCreate`: insert many records in one `INSERT` statement. */
+    bulkCreate<T = Record<string, unknown>>(table: string, rows: Array<Record<string, unknown>>): Promise<T[]>;
+    /**
+     * ORM `update`: merge `values` into every record matching `where` (or the
+     * whole table when `where` is omitted). Returns the updated records.
+     */
+    updateWhere<T = Record<string, unknown>>(table: string, values: Record<string, unknown>, where?: WhereClause): Promise<T[]>;
+    /**
+     * ORM `destroy`: delete every record matching `where` (or the whole table
+     * when `where` is omitted). Returns the number of records deleted.
+     */
+    destroy(table: string, where?: WhereClause): Promise<number>;
+    /** ORM `truncate`: delete every record in a table. */
+    truncate(table: string): Promise<number>;
+    /**
+     * Create a graph edge (association) between two records:
+     * `RELATE $from->edge->$to CONTENT $data`. This is how many-to-many /
+     * graph associations are expressed in SurrealDB, exposed through the ORM
+     * API so callers never hand-write the `RELATE` themselves.
+     */
+    relate<T = unknown>(from: string, edge: string, to: string, data?: Record<string, unknown>): Promise<T>;
+}
+export default SurrealStore;