ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,243 @@
+/**
+ * etcd store implementation.
+ *
+ * etcd is a distributed, strongly-consistent key-value store used for
+ * service discovery, distributed configuration and coordination primitives
+ * (leader election, distributed locking). It has no query language, no
+ * schema, and no `JOIN`/transaction-log concept in the SQL sense, so it does
+ * not fit the SQL-shaped `Dialect` interface used by the SQL dialects in
+ * this repo. Instead it implements the minimal `NoSqlStore` marker
+ * interface (`src/nosql/store.ts`) and exposes etcd's real primitives -
+ * key/value get/put/delete (including prefix range operations), watch
+ * (etcd's signature "subscribe to key/prefix changes" feature), leases
+ * (TTL-based key expiry with keep-alive), distributed locking, and
+ * compare-and-swap transactions - as a typed, promise-based API instead of
+ * forcing everything into a `query(sql)` shape.
+ *
+ * Uses the official `etcd3` driver.
+ */
+import { Etcd3, Watcher, ComparatorBuilder, PutBuilder, DeleteBuilder, SingleRangeBuilder } from 'etcd3';
+import { NoSqlStore } from '../store';
+/**
+ * TLS credentials for talking to etcd, mirroring `etcd3`'s `IOptions['credentials']`.
+ */
+export interface EtcdTlsOptions {
+    rootCertificate: Buffer;
+    privateKey?: Buffer;
+    certChain?: Buffer;
+}
+/** Username/password auth for etcd's built-in RBAC auth. */
+export interface EtcdAuthOptions {
+    username: string;
+    password: string;
+}
+/**
+ * Connection options for `EtcdStore`. A thin, typed subset of `etcd3`'s
+ * `IOptions` covering the fields most callers need; anything else can be
+ * reached via `getClient()`.
+ */
+export interface EtcdStoreOptions {
+    /** One or more etcd endpoints, e.g. `['http://127.0.0.1:2379']`. */
+    hosts: string[] | string;
+    /** TLS client credentials, if connecting over `https://`. */
+    credentials?: EtcdTlsOptions;
+    /** Username/password auth, if etcd's RBAC auth is enabled. */
+    auth?: EtcdAuthOptions;
+    /** Milliseconds to wait while connecting before timing out. Defaults to 30s (etcd3's default). */
+    dialTimeout?: number;
+}
+/** Options for `put()`. */
+export interface PutOptions {
+    /** Associate the key with an existing lease (see `grantLease()`), so it expires when the lease does. */
+    lease?: string | number;
+}
+/** Options for `grantLease()`. */
+export interface GrantLeaseOptions {
+    /**
+     * Whether the lease is kept alive automatically in the background.
+     * Defaults to `true`, matching `etcd3`. Set `false` to manage
+     * keep-alives yourself via `keepAliveOnce()`.
+     */
+    autoKeepAlive?: boolean;
+}
+/** A single watch change event, as delivered to `watch()`/`watchPrefix()` handlers. */
+export interface EtcdWatchEvent {
+    type: 'put' | 'delete';
+    key: string;
+    /** The new value for `put` events; `null` for `delete` events. */
+    value: string | null;
+    /** The value before this change, if `withPreviousKV` was requested (it is, by default). */
+    previousValue: string | null;
+}
+/** A handle returned by `watch()`/`watchPrefix()`. Call `cancel()` to stop watching. */
+export interface EtcdWatchHandle {
+    /** The underlying `etcd3` `Watcher`, for anything not wrapped here (e.g. `disconnected`/`error` events). */
+    readonly watcher: Watcher;
+    cancel(): Promise<void>;
+}
+/** A handle returned by `acquireLock()`. Call `release()` to free the lock. */
+export interface EtcdLockHandle {
+    /** The lease ID backing this lock, or `null` if the lock hasn't been acquired. */
+    leaseId(): Promise<string | null>;
+    release(): Promise<void>;
+}
+/**
+ * `EtcdStore` wraps an `etcd3` client and exposes etcd's real primitives:
+ * key/value get/put/delete (single-key and prefix-range), watch, leases,
+ * distributed locking, and compare-and-swap transactions.
+ */
+export declare class EtcdStore implements NoSqlStore {
+    readonly name = "etcd";
+    readonly library = "etcd3";
+    private readonly options;
+    private client;
+    private connected;
+    /** Leases granted through `grantLease()`, keyed by lease ID, so later calls can look them back up. */
+    private readonly leases;
+    constructor(options: EtcdStoreOptions);
+    private toClientOptions;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `etcd3` client for anything not wrapped here. */
+    getClient(): Etcd3;
+    private requireClient;
+    private exec;
+    putJSON<T>(key: string, value: T, options?: PutOptions): Promise<void>;
+    getJSON<T>(key: string): Promise<T | null>;
+    get(key: string): Promise<string | null>;
+    getBuffer(key: string): Promise<Buffer | null>;
+    put(key: string, value: string | number | Buffer, options?: PutOptions): Promise<void>;
+    /** Deletes a single key. Returns the number of keys actually deleted (`0` or `1`). */
+    delete(key: string): Promise<number>;
+    exists(key: string): Promise<boolean>;
+    /** All key/value pairs whose key starts with `prefix`. */
+    getPrefix(prefix: string): Promise<Record<string, string>>;
+    /** All keys (without values) starting with `prefix`. */
+    getKeysWithPrefix(prefix: string): Promise<string[]>;
+    /** Number of keys starting with `prefix`, without transferring their values. */
+    countPrefix(prefix: string): Promise<number>;
+    /** Deletes every key starting with `prefix`. Returns the number of keys deleted. */
+    deletePrefix(prefix: string): Promise<number>;
+    private attachWatchHandler;
+    /**
+     * Watch a single key for changes, invoking `handler` for every `put`/
+     * `delete` on that key. Returns a handle whose `cancel()` stops the
+     * underlying watch stream.
+     */
+    watch(key: string, handler: (event: EtcdWatchEvent) => void): Promise<EtcdWatchHandle>;
+    /**
+     * Watch every key starting with `prefix` for changes, invoking `handler`
+     * for every `put`/`delete` on any matching key. Returns a handle whose
+     * `cancel()` stops the underlying watch stream.
+     */
+    watchPrefix(prefix: string, handler: (event: EtcdWatchEvent) => void): Promise<EtcdWatchHandle>;
+    /**
+     * Grants a new lease with the given TTL (in seconds). By default the
+     * lease is kept alive automatically in the background (`autoKeepAlive`);
+     * pass `{ autoKeepAlive: false }` to manage keep-alives manually via
+     * `keepAliveOnce()`. Returns the lease ID, which can be passed to
+     * `put(key, value, { lease })` to associate keys with the lease so they
+     * expire automatically when it does.
+     */
+    grantLease(ttlSeconds: number, options?: GrantLeaseOptions): Promise<string>;
+    /** Puts `key`/`value` under a previously granted lease, so it expires when the lease does. */
+    putWithLease(key: string, value: string | number | Buffer, leaseId: string): Promise<void>;
+    /** Fires a single, immediate keep-alive for a lease, resetting its TTL countdown. */
+    keepAliveOnce(leaseId: string): Promise<void>;
+    /** Revokes a lease immediately, evicting every key still attached to it. */
+    revokeLease(leaseId: string): Promise<void>;
+    /**
+     * Stops sending keep-alives for a lease, letting it expire naturally when
+     * its TTL elapses, instead of revoking it immediately. Use `revokeLease()`
+     * to evict its keys right away.
+     */
+    releaseLease(leaseId: string): void;
+    /**
+     * Registers a handler that fires when etcd indicates a lease has been
+     * lost (TTL expired without a successful keep-alive, or it was revoked
+     * server-side). Not fired when `revokeLease()`/`releaseLease()` is called
+     * locally and succeeds normally.
+     */
+    onLeaseLost(leaseId: string, handler: (err: Error) => void): void;
+    private requireLease;
+    /**
+     * Acquires a distributed lock on `key`, blocking (queueing behind the
+     * current holder, in acquisition order) until it's free rather than
+     * rejecting immediately. Under the hood this is a lease on the key
+     * that's revoked on `release()`, or timed out by etcd if the holder
+     * dies - `ttlSeconds` controls that lease's TTL (etcd3 defaults to 30s).
+     *
+     * Note: `etcd3`'s own `Lock#acquire()` is a single compare-and-swap
+     * attempt - it *rejects immediately* with `EtcdLockFailedError` if the
+     * key already exists, rather than waiting, despite this store's docs
+     * (and the in-repo test mock) describing blocking/queueing semantics.
+     * To actually deliver that documented contract against a real etcd
+     * server, `acquireLockOrThrow()` below retries: on
+     * `EtcdLockFailedError` it watches the key until it's deleted (i.e. the
+     * current holder released or its lease expired), then retries the CAS.
+     * Multiple waiters can wake and race the retry simultaneously; that's
+     * fine because the retry is itself a CAS - at most one of them wins
+     * each round, and the rest go back to waiting.
+     */
+    acquireLock(key: string, ttlSeconds?: number): Promise<EtcdLockHandle>;
+    /**
+     * Wraps an acquired `etcd3` `Lock` in an `EtcdLockHandle`. `etcd3`'s own
+     * `Lock#leaseId()` keeps returning the (now-revoked) lease ID even after
+     * `release()` - verified against a real etcd server - which contradicts
+     * this handle's documented `null`-after-release contract, so track
+     * "released" locally instead of trusting the underlying lock for that.
+     */
+    private toLockHandle;
+    /**
+     * Acquires a distributed lock on `key`, runs `fn`, and releases the lock
+     * once `fn`'s result settles (whether it resolves or rejects). This is
+     * the recommended way to use locks - it can't leak a held lock the way
+     * manual `acquireLock()`/`release()` pairing can if `fn` throws.
+     */
+    withLock<T>(key: string, fn: () => T | Promise<T>, ttlSeconds?: number): Promise<T>;
+    /**
+     * Repeatedly attempts `client.lock(key).acquire()`, waiting for the key
+     * to be deleted (via a watch) and retrying whenever it fails with
+     * `EtcdLockFailedError`, so the returned promise doesn't settle until
+     * the lock is actually acquired (see `acquireLock()` above for why this
+     * is necessary against a real etcd server).
+     */
+    private acquireLockOrThrow;
+    /** Resolves once `key` no longer exists (already gone, or deleted while we watch it). */
+    private waitForKeyDeletion;
+    /**
+     * Starts a raw etcd transaction: `if (key.<column> <cmp> value) { ... }`.
+     * Returns etcd3's `ComparatorBuilder` directly so callers get its full
+     * `.and()/.then()/.else()/.commit()` chain; combine with `putOp()`/
+     * `deleteOp()`/`getOp()` below to build the `then`/`else` clauses.
+     *
+     * ```typescript
+     * const result = await store
+     *   .ifCompare('config-version', 'Value', '==', '1')
+     *   .then(store.putOp('config-version', '2'))
+     *   .else(store.getOp('config-version'))
+     *   .commit();
+     * ```
+     */
+    ifCompare(key: string, column: 'Version' | 'Create' | 'Mod' | 'Value' | 'Lease', cmp: '==' | '===' | '>' | '<' | '!=' | '!==', value: string | Buffer | number): ComparatorBuilder;
+    /** A `put` operation builder, for use as a `.then()`/`.else()` clause in `ifCompare()`. */
+    putOp(key: string, value: string | number | Buffer): PutBuilder;
+    /** A `delete` operation builder, for use as a `.then()`/`.else()` clause in `ifCompare()`. */
+    deleteOp(key: string): DeleteBuilder;
+    /** A `get` operation builder, for use as a `.then()`/`.else()` clause in `ifCompare()`. */
+    getOp(key: string): SingleRangeBuilder;
+    /**
+     * Convenience compare-and-swap: atomically sets `key` to `newValue` only
+     * if its current value equals `expectedValue` (or, if `expectedValue` is
+     * `null`, only if the key does not currently exist). Returns whether the
+     * swap happened.
+     */
+    compareAndSwap(key: string, expectedValue: string | null, newValue: string | number | Buffer): Promise<boolean>;
+    /**
+     * Atomically deletes `key` only if its current value equals
+     * `expectedValue`. Returns whether the delete happened.
+     */
+    compareAndDelete(key: string, expectedValue: string): Promise<boolean>;
+}
+export default EtcdStore;

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

@@ -0,0 +1,89 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`: raw string/Buffer or a JSON-serializable value. */
+export type EventHubsMessage = string | Buffer | Record<string, unknown> | unknown[];
+/** Minimal structural view of an `EventHubProducerClient`. */
+export interface EventHubProducerLike {
+    sendBatch(events: unknown, options?: unknown): Promise<unknown>;
+    close?(): Promise<void>;
+}
+/** Minimal structural view of an `EventHubConsumerClient`. */
+export interface EventHubConsumerLike {
+    subscribe(handlers: unknown, options?: unknown): {
+        close(): Promise<void>;
+    };
+    close?(): Promise<void>;
+}
+/**
+ * Minimal structural view of the `@azure/event-hubs` module (its two client
+ * constructors). Tests inject a mock of this shape via `options.client`.
+ */
+export interface EventHubsModuleLike {
+    EventHubProducerClient: new (...args: any[]) => EventHubProducerLike;
+    EventHubConsumerClient: new (...args: any[]) => EventHubConsumerLike;
+}
+/** Connection options for `EventHubsStore`. */
+export interface EventHubsStoreOptions {
+    /** Event Hubs namespace connection string. */
+    connectionString?: string;
+    /** Default event hub (entity) name used when `publish`/`subscribe` omit one. */
+    eventHubName?: string;
+    /** Consumer group used by `subscribe()`. Defaults to '$Default'. */
+    consumerGroup?: string;
+    /**
+     * A pre-built `@azure/event-hubs` module (or a mock exposing the two client
+     * constructors). When provided, `connect()` uses it directly and does NOT
+     * require the driver — this is how tests inject mocks.
+     */
+    client?: EventHubsModuleLike;
+}
+/** Options for `subscribe()`. */
+export interface EventHubsSubscribeOptions {
+    /** Consumer group override (defaults to the store's `consumerGroup`). */
+    consumerGroup?: string;
+    /** Start reading from the earliest available event rather than the latest. */
+    startFromEarliest?: boolean;
+}
+/** A handle returned by `subscribe()`; call `stop()` to end the subscription. */
+export interface EventHubsSubscription {
+    stop(): Promise<void>;
+}
+/**
+ * `EventHubsStore` wraps `@azure/event-hubs` producer/consumer clients and
+ * exposes event publishing and consumer subscriptions.
+ */
+export declare class EventHubsStore implements NoSqlStore {
+    readonly name = "eventhubs";
+    readonly library = "@azure/event-hubs";
+    private readonly options;
+    private azure;
+    private producer;
+    /** Producers cached by event hub name (the default hub plus any others used). */
+    private readonly producers;
+    /** Active consumer subscriptions, tracked so `disconnect()` can close them. */
+    private readonly consumers;
+    private connected;
+    constructor(options?: EventHubsStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying default `EventHubProducerClient` for anything not wrapped here. */
+    getClient(): EventHubProducerLike;
+    private requireModule;
+    /** Resolve (and cache) a producer for a given event hub name. */
+    private producerFor;
+    private wrapError;
+    /**
+     * Send one `message` to `eventHubName` (or the store's default hub) as a
+     * single-event batch via `EventHubProducerClient.sendBatch`. The message is
+     * encoded per the module's rules (string/Buffer as-is, else JSON string).
+     */
+    publish(eventHubName: string, message: EventHubsMessage): Promise<void>;
+    /**
+     * Subscribe a new `EventHubConsumerClient` to `eventHubName`, invoking
+     * `handler` once per received event. Returns a subscription whose `stop()`
+     * closes both the underlying subscription and consumer client; the
+     * subscription is tracked so `disconnect()` closes it too.
+     */
+    subscribe(eventHubName: string, handler: (event: any) => void | Promise<void>, options?: EventHubsSubscribeOptions): Promise<EventHubsSubscription>;
+}
+export default EventHubsStore;

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

@@ -0,0 +1,102 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`. */
+export type EventStoreMessage = string | Buffer | Record<string, unknown> | unknown[];
+/** Minimal structural view of an `EventStoreDBClient`. */
+export interface EventStoreClientLike {
+    appendToStream(stream: string, events: unknown, options?: unknown): Promise<any>;
+    subscribeToStream(stream: string, options?: unknown): AsyncIterable<any> & {
+        unsubscribe?(): void;
+    };
+    readStream(stream: string, options?: unknown): AsyncIterable<any>;
+    dispose?(): Promise<void>;
+}
+/** Connection options for `EventStoreStore`. */
+export interface EventStoreStoreOptions {
+    /**
+     * EventStoreDB connection string, e.g.
+     * 'esdb://localhost:2113?tls=false'. Used to build the client via
+     * `EventStoreDBClient.connectionString(...)`.
+     */
+    connectionString?: string;
+    /**
+     * A pre-built `EventStoreDBClient` (or a mock exposing the methods above).
+     * When provided, `connect()` uses it directly and does NOT require the driver
+     * — this is how tests inject a mock client.
+     */
+    client?: EventStoreClientLike;
+}
+/** Options for `publish()`. */
+export interface AppendOptions {
+    /** Event type recorded on the event. Defaults to 'message'. */
+    type?: string;
+    /** Optional metadata object attached to the event. */
+    metadata?: Record<string, unknown>;
+    /** Optional explicit event id (UUID). */
+    id?: string;
+    /** Expected stream revision / state for optimistic concurrency. */
+    expectedRevision?: unknown;
+}
+/** Options for `subscribe()`. */
+export interface EventStoreSubscribeOptions {
+    /** Start position: 'start', 'end', or a specific revision. Defaults to 'end'. */
+    fromRevision?: 'start' | 'end' | bigint;
+    /** Resolve link events to the events they point at. */
+    resolveLinkTos?: boolean;
+}
+/** A handle returned by `subscribe()`; call `stop()` to end the subscription. */
+export interface EventStoreSubscription {
+    stop(): void;
+}
+/**
+ * `EventStoreStore` wraps an `@eventstore/db-client` `EventStoreDBClient` and
+ * exposes appending events, catch-up subscriptions, and stream reads.
+ */
+export declare class EventStoreStore implements NoSqlStore {
+    readonly name = "eventstore";
+    readonly library = "@eventstore/db-client";
+    private readonly options;
+    private client;
+    private esdb;
+    private connected;
+    /** Active subscriptions, tracked so `disconnect()` can end them. */
+    private readonly subscriptions;
+    constructor(options?: EventStoreStoreOptions);
+    connect(): Promise<void>;
+    private tryLoadSdk;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `EventStoreDBClient` for anything not wrapped here. */
+    getClient(): EventStoreClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Append one event carrying `message` to `stream` via `appendToStream`. The
+     * message is turned into a JSON event (`jsonEvent`) with `options.type`
+     * (default 'message'). Returns the driver's append result (next expected
+     * revision, etc.).
+     */
+    publish(stream: string, message: EventStoreMessage, options?: AppendOptions): Promise<any>;
+    /**
+     * Streams are created implicitly by the first append in EventStoreDB, so this
+     * is a documented no-op that resolves without contacting the server. Provided
+     * to satisfy the common store surface (alias `createTopic`).
+     */
+    createStream(_name: string): Promise<void>;
+    /** Alias for `createStream()`, matching the common store surface. */
+    createTopic(name: string): Promise<void>;
+    /**
+     * Read events from `stream` into an array by draining the driver's async
+     * iterable. Options (`fromRevision`, `maxCount`, `direction`, ...) are passed
+     * straight through.
+     */
+    readStream(stream: string, options?: unknown): Promise<any[]>;
+    /**
+     * Subscribe to `stream` with a catch-up subscription (`subscribeToStream`),
+     * invoking `handler` once per resolved event. Returns a subscription whose
+     * `stop()` ends it; it is tracked so `disconnect()` ends it too. The
+     * consuming loop runs detached (not awaited); this method resolves once the
+     * subscription is opened.
+     */
+    subscribe(stream: string, handler: (event: any) => void | Promise<void>, options?: EventStoreSubscribeOptions): Promise<EventStoreSubscription>;
+}
+export default EventStoreStore;

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

@@ -0,0 +1,141 @@
+/**
+ * FaunaDB store implementation for the Prorm NoSQL layer.
+ *
+ * Fauna is a multi-model, distributed database (document, relational, graph)
+ * driven by FQL - a functional query language expressed as composed function
+ * calls rather than SQL strings. It does not fit the SQL-shaped `Dialect`
+ * interface, so this class implements the minimal `NoSqlStore` marker
+ * interface for connection lifecycle and otherwise exposes Fauna's real
+ * document CRUD (built from FQL expressions) plus a raw FQL `query` escape
+ * hatch.
+ *
+ * Uses the official `faunadb` driver. That driver is an optional peer
+ * dependency and is loaded lazily inside `connect()` so importing this module
+ * never requires it to be installed. Tests inject a pre-built mock `client`
+ * (and FQL builder `q`) via options, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A native `faunadb.Client` handle, left untyped because the driver is an
+ * optional dependency not imported here. */
+type FaunaClient = any;
+/** The FQL query builder (`faunadb.query`). */
+type FaunaQuery = any;
+/**
+ * Connection options for `FaunaDbStore`.
+ *
+ * `secret` authenticates against a Fauna database. When a pre-built `client`
+ * is supplied (e.g. in tests), `connect()` uses it directly and skips loading
+ * the `faunadb` driver; the FQL builder `q` may likewise be injected so tests
+ * need not require the driver at all.
+ */
+export interface FaunaDbStoreOptions {
+    /** Fauna database secret / access key. */
+    secret?: string;
+    /** Fauna endpoint domain, e.g. `db.fauna.com`. */
+    domain?: string;
+    /** A pre-built `faunadb.Client` to use instead of the driver. */
+    client?: FaunaClient;
+    /** A pre-built FQL builder (`faunadb.query`) to use instead of the driver. */
+    q?: FaunaQuery;
+}
+/** Sort direction accepted by {@link FaunaDbStore.findAll}'s `order`. */
+export type FaunaOrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc';
+/** Options for {@link FaunaDbStore.findAll}/{@link FaunaDbStore.findOne}. */
+export interface FaunaFindOptions {
+    /** ORM `where` clause (plain equality and/or `Op`-keyed conditions). */
+    where?: Record<string, any>;
+    /** Ordering, e.g. `[['age', 'DESC'], ['name', 'ASC']]` (applied client-side). */
+    order?: Array<[string, FaunaOrderDirection]>;
+    /** Maximum documents to return (applied client-side). */
+    limit?: number;
+    /** Documents to skip (applied client-side). */
+    offset?: number;
+    /**
+     * FQL page size fetched from Fauna before filtering. Defaults to 100000
+     * (Fauna's maximum). For collections larger than a single page, supply a
+     * covering index and use the raw {@link FaunaDbStore.query} escape hatch.
+     */
+    pageSize?: number;
+}
+export declare class FaunaDbStore implements NoSqlStore {
+    readonly name = "faunadb";
+    readonly library = "faunadb";
+    private readonly options;
+    private client;
+    private q;
+    private connected;
+    constructor(options?: FaunaDbStoreOptions);
+    connect(): Promise<void>;
+    private tryRequireQuery;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getClient(): FaunaClient;
+    private requireClient;
+    private requireQuery;
+    /** Create a document in `collection`; returns the new document's id. */
+    insert(collection: string, doc: Record<string, unknown>): Promise<unknown>;
+    /** Fetch a document by id, returning its `data`. */
+    get(collection: string, id: string): Promise<unknown>;
+    /** Merge `patch` into a document's `data`, returning the updated data. */
+    update(collection: string, id: string, patch: Record<string, unknown>): Promise<unknown>;
+    /** Delete a document by id. */
+    delete(collection: string, id: string): Promise<unknown>;
+    /**
+     * Run an FQL query. When `expr` is provided it is executed directly;
+     * otherwise all documents in `collection` are paginated and dereferenced.
+     * Returns the query's `data` array.
+     */
+    query(collection: string, expr?: unknown): Promise<unknown[]>;
+    /**
+     * Fetch every document in `collection` matching the ORM `where` clause. The
+     * `where` is compiled to an FQL predicate applied via `Filter` over the
+     * collection's documents; `order`/`limit`/`offset` are applied client-side.
+     * Each result is normalized to its `data` fields plus an `id`.
+     *
+     * This scans the collection (bounded by `pageSize`). For large collections,
+     * define a Fauna index and use the raw {@link query} escape hatch for an
+     * index-driven read.
+     */
+    findAll<T = Record<string, unknown>>(collection: string, options?: FaunaFindOptions): Promise<T[]>;
+    /** Fetch the first document matching `where` (client-side `limit 1`), or `null`. */
+    findOne<T = Record<string, unknown>>(collection: string, options?: FaunaFindOptions): Promise<T | null>;
+    /** Count documents in `collection` matching `where`. */
+    count(collection: string, where?: Record<string, any>): Promise<number>;
+    /** Insert `data` and return the new document's id. Alias of {@link insert}. */
+    create(collection: string, data: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Insert many documents atomically in a single FQL `Map`/`Create`, returning
+     * the new document ids in order.
+     */
+    bulkCreate(collection: string, docs: Array<Record<string, unknown>>): Promise<unknown[]>;
+    /**
+     * Update every document matching `where`, merging `values` into each match's
+     * `data`, all in a single atomic FQL expression. Returns the number of
+     * documents updated.
+     */
+    updateMany(collection: string, values: Record<string, unknown>, where?: Record<string, any>): Promise<number>;
+    /**
+     * Delete every document matching `where` in a single atomic FQL expression.
+     * Returns the number of documents deleted.
+     */
+    destroy(collection: string, where?: Record<string, any>): Promise<number>;
+    /**
+     * Insert-or-update: if a document matching `where` exists, merge `data` into
+     * the first match; otherwise create a new document seeded with the `where`
+     * equality keys plus `data`. Returns `{ created }`.
+     */
+    upsert(collection: string, data: Record<string, unknown>, where: Record<string, any>): Promise<{
+        created: boolean;
+    }>;
+    /**
+     * Run several FQL write expressions atomically in a single transaction via
+     * FQL's `Do` (Fauna evaluates a single query as one serializable
+     * transaction). Pass expressions built with the query builder from
+     * {@link getQuery}. Returns the value of the last expression.
+     */
+    transaction(expressions: unknown[]): Promise<unknown>;
+    /** Exposes the FQL query builder (`faunadb.query`) for building raw expressions. */
+    getQuery(): FaunaQuery;
+}
+export default FaunaDbStore;