ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,126 @@
+/**
+ * Grafana Loki store implementation.
+ *
+ * Loki is a horizontally-scalable, multi-tenant log aggregation system. It
+ * indexes only a small set of labels per log stream (not the log contents)
+ * and is queried with LogQL, a label-matcher + filter language modelled on
+ * PromQL. There is no SQL-shaped query surface, no row-level UPDATE/DELETE,
+ * and no identifier escaping, so Loki 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 Loki's
+ * HTTP push/query API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Loki has no single canonical npm client; it is just an HTTP/JSON API.
+ * Rather than depend on any package, this store talks to the server with
+ * the global `fetch` (so `library` is `'fetch'`). For tests (and for callers
+ * who want their own transport), an alternative HTTP client can be injected
+ * via `LokiStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `baseURL` is built at connect time.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(labels, entries)` -> `POST /loki/api/v1/push`  (ingest log lines)
+ * - `query(logql, opts?)`   -> `GET  /loki/api/v1/query_range`  (search)
+ * - `labels()`              -> `GET  /loki/api/v1/labels`  (label names)
+ * - `streams(match?)`       -> `GET  /loki/api/v1/series`  (label sets)
+ */
+import { NoSqlStore } from '../store';
+/** Default Grafana Loki HTTP API base URL. */
+export declare const DEFAULT_LOKI_BASE_URL = "http://localhost:3100";
+/** 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 LokiHttpClient {
+    /** 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 `LokiStore`. */
+export interface LokiStoreOptions {
+    /** Base URL of the Loki server. Defaults to `http://localhost:3100`. */
+    baseURL?: string;
+    /**
+     * Optional pre-built HTTP client. When provided it is used verbatim and
+     * `baseURL` is ignored; otherwise an internal `fetch`-based client is
+     * built against `baseURL` on `connect()`.
+     */
+    client?: LokiHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+    /** Optional tenant ID sent as the `X-Scope-OrgID` header. */
+    tenantID?: string;
+}
+/** A single log entry to push: timestamp (ns epoch string) + line. */
+export interface LokiEntry {
+    /** Timestamp as a Unix-epoch nanosecond string (Loki's native format). */
+    ts: string | number;
+    /** The raw log line. */
+    line: string;
+    /** Optional structured metadata attached to this entry. */
+    metadata?: Record<string, string>;
+}
+/** Options for a LogQL range query. */
+export interface LokiQueryOptions {
+    /** Start of the query window (Unix nanoseconds or RFC3339). */
+    start?: string | number;
+    /** End of the query window (Unix nanoseconds or RFC3339). */
+    end?: string | number;
+    /** Max number of entries to return. */
+    limit?: number;
+    /** Result order: `'forward'` (oldest first) or `'backward'` (newest first). */
+    direction?: 'forward' | 'backward';
+    /** Query resolution step for metric queries. */
+    step?: string | number;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): LokiHttpClient;
+/**
+ * `LokiStore` wraps Grafana Loki's HTTP push/query API (log ingestion via
+ * the push endpoint, LogQL range search, and label/series metadata lookups)
+ * behind the `NoSqlStore` lifecycle.
+ */
+export declare class LokiStore implements NoSqlStore {
+    readonly name = "loki";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: LokiStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): LokiHttpClient;
+    private requireClient;
+    private doGet;
+    /**
+     * Pushes a batch of log entries for one stream (identified by its label
+     * set) via `POST /loki/api/v1/push`. Each entry is serialized as
+     * `[<ts-ns>, <line>]` (plus optional structured metadata) in Loki's
+     * push payload shape.
+     */
+    push(labels: Record<string, string>, entries: LokiEntry[]): Promise<any>;
+    /**
+     * Runs a LogQL query over a time window via `GET /loki/api/v1/query_range`.
+     * Returns the `data` payload (`{ resultType, result }`).
+     */
+    query(logql: string, options?: LokiQueryOptions): Promise<any>;
+    /** Lists the known label names via `GET /loki/api/v1/labels`. */
+    labels(): Promise<any>;
+    /**
+     * Lists the label sets (streams) matching an optional selector via
+     * `GET /loki/api/v1/series`.
+     */
+    streams(match?: string | string[]): Promise<any>;
+    /** Lists the distinct values of a label via `GET /loki/api/v1/label/<name>/values`. */
+    labelValues(label: string): Promise<any>;
+}
+export default LokiStore;

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

@@ -0,0 +1,76 @@
+/**
+ * MarkLogic store implementation for the Prorm NoSQL layer.
+ *
+ * MarkLogic is a multi-model database (document, graph/RDF triples, search,
+ * relational views) where documents are addressed by an opaque URI. It does
+ * not fit the SQL-shaped `Dialect` interface, so this class implements the
+ * minimal `NoSqlStore` marker interface for connection lifecycle and exposes
+ * MarkLogic's real `documents.write/read/remove` plus `documents.query` API
+ * through a small document-CRUD convenience layer. Collection + id are mapped
+ * to a URI of the form `/<collection>/<id>.json`.
+ *
+ * Uses the official `marklogic` 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 `queryBuilder`) via options, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A native MarkLogic database client, left untyped because the driver is an
+ * optional dependency not imported here. */
+type MarkLogicClient = any;
+/** The MarkLogic `queryBuilder` factory. */
+type QueryBuilder = any;
+/**
+ * Connection options for `MarkLogicStore`.
+ *
+ * `host`/`port`/`user`/`password`/`authType` are passed to
+ * `createDatabaseClient`. When a pre-built `client` is supplied (e.g. in
+ * tests), `connect()` uses it directly and skips loading the `marklogic`
+ * driver; `queryBuilder` may likewise be injected.
+ */
+export interface MarkLogicStoreOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    authType?: string;
+    database?: string;
+    /** A pre-built MarkLogic client to use instead of the driver. */
+    client?: MarkLogicClient;
+    /** A pre-built `queryBuilder` to use instead of the driver. */
+    queryBuilder?: QueryBuilder;
+}
+export declare class MarkLogicStore implements NoSqlStore {
+    readonly name = "marklogic";
+    readonly library = "marklogic";
+    private readonly options;
+    private client;
+    private qb;
+    private connected;
+    constructor(options?: MarkLogicStoreOptions);
+    connect(): Promise<void>;
+    private tryRequireQueryBuilder;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getClient(): MarkLogicClient;
+    private requireClient;
+    private uri;
+    /** Write a document into `collection`; returns the id used. */
+    insert(collection: string, doc: Record<string, unknown>): Promise<unknown>;
+    /** Read a document by id, returning its stored `content`. */
+    get(collection: string, id: string): Promise<unknown>;
+    /** Merge `patch` into an existing document and re-write it. */
+    update(collection: string, id: string, patch: Record<string, unknown>): Promise<unknown>;
+    /** Remove a document by id. */
+    delete(collection: string, id: string): Promise<unknown>;
+    /**
+     * Query documents. When `builtQuery` is provided it is passed straight to
+     * `documents.query`; otherwise all documents in `collection` are matched via
+     * `queryBuilder.where(queryBuilder.collection(collection))`. Returns the
+     * result documents.
+     */
+    query(collection: string, builtQuery?: unknown): Promise<unknown[]>;
+    private buildCollectionQuery;
+}
+export default MarkLogicStore;

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

@@ -0,0 +1,91 @@
+/**
+ * Materialize store.
+ *
+ * Materialize is a streaming (incrementally-updated) analytics database: you
+ * define SOURCEs over event streams and MATERIALIZED VIEWs whose results are
+ * kept continuously up to date as new data arrives, then read them with
+ * low-latency SQL. Materialize speaks the **PostgreSQL wire protocol**, so it
+ * is driven with the `pg` client over a normal Postgres-style connection.
+ * Although the wire is Postgres, Materialize's compute model (streaming
+ * dataflows, `SUBSCRIBE`, `CREATE SOURCE`) is not a general OLTP relational
+ * store and does not fit this ORM's SQL `Dialect` abstraction, so it is
+ * modelled as a `NoSqlStore` (`src/nosql/store.ts`) exposing a direct `query`
+ * surface plus source/view helpers.
+ *
+ * ## Driver: `pg` (PostgreSQL-wire)
+ *
+ * The `pg` 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 `MaterializeStoreOptions.client`, which
+ * skips the `require` entirely.
+ */
+import type { NoSqlStore } from '../store';
+/**
+ * Minimal structural type for the pieces of a `pg` `Client` this store uses.
+ * Kept local so this module type-checks without the optional driver installed.
+ * `query()` resolves to a result object with a `rows` array.
+ */
+export interface PgClientLike {
+    connect(): Promise<void>;
+    query(sql: string, params?: unknown[]): Promise<{
+        rows: any[];
+        [key: string]: unknown;
+    }>;
+    end(): Promise<void>;
+}
+/** Connection options for `MaterializeStore` (map onto `pg` client config). */
+export interface MaterializeStoreOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    /** Full connection string (`postgres://...`), an alternative to the discrete fields. */
+    connectionString?: string;
+    /** Escape hatch for any other `pg` client option. */
+    connectionOptions?: Record<string, unknown>;
+    /**
+     * A pre-built `pg` `Client` (or compatible mock). When provided, `connect()`
+     * uses it directly and skips `require('pg')`. This is how tests inject a
+     * mock without the real driver installed.
+     */
+    client?: PgClientLike;
+}
+/**
+ * `MaterializeStore` wraps a `pg` client connected to Materialize and exposes
+ * `query(sql, params)` for reads/DDL, plus `createSource()` and
+ * `createMaterializedView()` convenience helpers for the streaming-specific
+ * DDL that defines what Materialize keeps incrementally up to date.
+ */
+export declare class MaterializeStore implements NoSqlStore {
+    readonly name = "materialize";
+    readonly library = "pg";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: MaterializeStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `pg` client for anything not wrapped here. */
+    getClient(): PgClientLike;
+    private requireClient;
+    /**
+     * Execute a SQL statement over the Postgres wire with optional positional
+     * `params` and return the result rows (`pg`'s `result.rows`).
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Create a streaming SOURCE via `CREATE SOURCE <name> <definition>`, e.g.
+     * `createSource('kafka_src', "FROM KAFKA CONNECTION ... (TOPIC 'events')")`.
+     * Returns the driver result rows.
+     */
+    createSource(name: string, definition: string): Promise<any[]>;
+    /**
+     * Create a MATERIALIZED VIEW (kept incrementally up to date) via
+     * `CREATE MATERIALIZED VIEW <name> AS <selectSql>`. Returns the driver
+     * result rows.
+     */
+    createMaterializedView(name: string, selectSql: string): Promise<any[]>;
+}
+export default MaterializeStore;

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

@@ -0,0 +1,76 @@
+/**
+ * Meilisearch store implementation.
+ *
+ * Meilisearch is a search engine built around an inverted index with
+ * typo-tolerant, prefix, full-text search and faceting rather than SQL: no
+ * `JOIN`, no transaction log, schema-flexible documents grouped into indexes
+ * (each identified by a `uid` and a primary key). It therefore 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 Meilisearch's real capabilities grouped
+ * by concern: connection lifecycle, index management and document CRUD/search.
+ *
+ * Uses the official `meilisearch` JS driver. The driver is loaded lazily via
+ * `require` so importing this module does not force the dependency to be
+ * resolved unless a Meilisearch store is actually constructed. For
+ * unit-testing without a live server, the constructor also accepts an
+ * already-built `client`, which `connect()` will use as-is instead of
+ * instantiating a new one.
+ *
+ * Most operations are scoped to an index and reached through
+ * `client.index(uid).<op>(...)`; index lifecycle (`createIndex`/`deleteIndex`)
+ * and cluster stats live directly on the top-level client.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `MeilisearchStore`.
+ *
+ * `host` and `apiKey` are passed straight through to the driver's
+ * `new MeiliSearch(...)`. Pass `client` to inject an already-built client
+ * instance (used in tests and when the caller wants full control over driver
+ * configuration); when present, `host`/`apiKey` are ignored.
+ */
+export interface MeilisearchStoreOptions {
+    /** URL of the Meilisearch server, e.g. `http://localhost:7700`. */
+    host?: string;
+    /** API key used to authenticate against the server. */
+    apiKey?: string;
+    /** An already-constructed Meilisearch client to use instead of building one. */
+    client?: any;
+    /** Any additional options passed through to the driver's client. */
+    [key: string]: unknown;
+}
+/**
+ * `MeilisearchStore` wraps the official `meilisearch` client and exposes
+ * index management, document CRUD, and search as a typed, promise-based API.
+ */
+export declare class MeilisearchStore implements NoSqlStore {
+    readonly name = "meilisearch";
+    readonly library = "meilisearch";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options: MeilisearchStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `meilisearch` client for anything not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    private exec;
+    /** Create an index by `uid`, optionally specifying its primary key via `options`. */
+    createIndex(uid: string, options?: Record<string, unknown>): Promise<any>;
+    /** Delete an index by `uid`. */
+    deleteIndex(uid: string): Promise<any>;
+    /** Add (or replace) documents in an index. Returns the enqueued task. */
+    addDocuments(index: string, documents: Record<string, unknown>[], options?: Record<string, unknown>): Promise<any>;
+    /** Run a search against an index and return the `hits` array from the response. */
+    search<T = Record<string, unknown>>(index: string, query: string, options?: Record<string, unknown>): Promise<T[]>;
+    /** Get a single document by its primary-key value. */
+    getDocument<T = Record<string, unknown>>(index: string, id: string | number): Promise<T>;
+    /** Delete a single document by its primary-key value. Returns the enqueued task. */
+    deleteDocument(index: string, id: string | number): Promise<any>;
+    /** Get server-wide stats (database size, per-index document counts, etc.). */
+    getStats(): Promise<any>;
+}
+export default MeilisearchStore;

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

@@ -0,0 +1,138 @@
+/**
+ * Memcached store implementation.
+ *
+ * Memcached is a distributed in-memory key-value cache. It has no query
+ * language, no secondary indexes and no persistence, so it does not fit the
+ * SQL-shaped `Dialect` interface. This class implements the minimal
+ * `NoSqlStore` marker interface and exposes Memcached's real operations
+ * (set/get/delete/add/replace/increment/decrement/flush) as a typed,
+ * promise-based API instead of forcing them into a `query(sql)` shape.
+ *
+ * Uses the `memjs` driver. The driver is loaded lazily inside `connect()`
+ * (or supplied pre-built via the `client` option) so importing this module
+ * never requires `memjs` to be installed unless a Memcached store is
+ * actually connected.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * Options passed straight through to memjs per-operation (e.g. `expires`).
+ * memjs accepts an `expires` TTL in seconds on set/add/replace/increment/
+ * decrement; anything memjs supports is forwarded unchanged.
+ */
+export interface MemcachedWriteOptions {
+    /** Time-to-live in seconds (0 = never expire, the memjs default). */
+    expires?: number;
+    [key: string]: unknown;
+}
+/**
+ * How `get()` should decode the stored value.
+ *
+ * - `'buffer'` (default): return the raw `Buffer` exactly as memjs read it.
+ * - `'string'`: decode the buffer to a UTF-8 string.
+ * - `'json'`: decode to a string and `JSON.parse` it (the inverse of the
+ *   automatic JSON serialization `set()` applies to non-string/Buffer
+ *   values).
+ */
+export type MemcachedDecode = 'buffer' | 'string' | 'json';
+/** Options for `get()`. */
+export interface MemcachedGetOptions {
+    /** Decode strategy for the stored value. Defaults to `'buffer'`. */
+    decode?: MemcachedDecode;
+}
+/**
+ * Connection options for `MemcachedStore`.
+ *
+ * `servers` is a comma-separated list of `host:port` entries (memjs's
+ * standard format, e.g. `"localhost:11211"` or
+ * `"cache1:11211,cache2:11211"`). `options` is passed straight through to
+ * `memjs.Client.create(servers, options)`. Supply a pre-built memjs
+ * `client` to skip the lazy `require('memjs')` entirely (used by tests to
+ * inject a mock, and by callers who manage the client themselves).
+ */
+export interface MemcachedStoreOptions {
+    /** Comma-separated `host:port` server list. Defaults to memjs's own default. */
+    servers?: string;
+    /** memjs client options (username/password/timeout/retries/etc). */
+    options?: Record<string, unknown>;
+    /** Pre-built memjs client; when given, `connect()` uses it and skips `require('memjs')`. */
+    client?: unknown;
+}
+/** The subset of the memjs client surface this store drives. */
+interface MemjsClient {
+    set(key: string, value: string | Buffer, options?: Record<string, unknown>): Promise<boolean>;
+    get(key: string): Promise<{
+        value: Buffer | null;
+        flags: Buffer | number | null;
+    } | null>;
+    delete(key: string): Promise<boolean>;
+    add(key: string, value: string | Buffer, options?: Record<string, unknown>): Promise<boolean>;
+    replace(key: string, value: string | Buffer, options?: Record<string, unknown>): Promise<boolean>;
+    increment(key: string, amount: number, options?: Record<string, unknown>): Promise<{
+        value: number | null;
+        success: boolean;
+    }>;
+    decrement(key: string, amount: number, options?: Record<string, unknown>): Promise<{
+        value: number | null;
+        success: boolean;
+    }>;
+    flush(): Promise<unknown>;
+    close?(): void;
+    quit?(): void;
+}
+/**
+ * `MemcachedStore` wraps a `memjs` client and exposes Memcached's key-value
+ * operations as a typed, promise-based API.
+ */
+export declare class MemcachedStore implements NoSqlStore {
+    readonly name = "memcached";
+    readonly library = "memjs";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: MemcachedStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /** Alias for `disconnect()`, mirroring memjs's own `quit()`/`close()` naming. */
+    quit(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `memjs` client for anything not wrapped here. */
+    getClient(): MemjsClient;
+    private requireClient;
+    /**
+     * Store `value` under `key`, overwriting any existing value. Strings and
+     * Buffers are stored verbatim; other values are JSON-serialized (see
+     * `serialize`). Returns memjs's boolean success flag.
+     */
+    set(key: string, value: unknown, options?: MemcachedWriteOptions): Promise<boolean>;
+    /**
+     * Read `key`. Returns `null` if the key is missing. By default returns the
+     * raw `Buffer`; pass `{ decode: 'string' }` or `{ decode: 'json' }` to
+     * decode the stored value.
+     */
+    get(key: string, options?: MemcachedGetOptions): Promise<Buffer | string | unknown | null>;
+    /** Delete `key`. Returns memjs's boolean success flag. */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Store `value` under `key` only if the key does not already exist
+     * (Memcached `add`). Returns `false` if the key was already present.
+     */
+    add(key: string, value: unknown, options?: MemcachedWriteOptions): Promise<boolean>;
+    /**
+     * Store `value` under `key` only if the key already exists (Memcached
+     * `replace`). Returns `false` if the key was missing.
+     */
+    replace(key: string, value: unknown, options?: MemcachedWriteOptions): Promise<boolean>;
+    /** Atomically increment the numeric value at `key` by `amount`. */
+    increment(key: string, amount: number, options?: MemcachedWriteOptions): Promise<{
+        value: number | null;
+        success: boolean;
+    }>;
+    /** Atomically decrement the numeric value at `key` by `amount`. */
+    decrement(key: string, amount: number, options?: MemcachedWriteOptions): Promise<{
+        value: number | null;
+        success: boolean;
+    }>;
+    /** Flush (delete) all keys across every configured server. */
+    flush(): Promise<unknown>;
+}
+export default MemcachedStore;

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

@@ -0,0 +1,167 @@
+/**
+ * Milvus store implementation.
+ *
+ * Milvus is a vector database: collections are defined by a field schema
+ * (a primary key, one or more vector fields with a fixed dimension, and
+ * optional scalar fields) rather than rows of arbitrary SQL types, queries
+ * are approximate-nearest-neighbor searches (or scalar filter expressions)
+ * rather than `SELECT ... WHERE`, and there is no join/transaction-log
+ * concept. None of that fits the SQL-shaped `Dialect` interface, so this
+ * class implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes Milvus's real operations (collection
+ * management, index management, insert/upsert, vector search, scalar
+ * query, delete, and partitions) grouped the way the underlying SDK groups
+ * them, instead of forcing everything into a `query(sql)` shape.
+ *
+ * Uses the official `@zilliz/milvus2-sdk-node` gRPC client.
+ */
+import { MilvusClient, DataType, type ClientConfig, type DescribeCollectionResponse, type CollectionData, type RowData, type MutationResult, type ConsistencyLevelEnum } from '@zilliz/milvus2-sdk-node';
+import type { NoSqlStore } from '../store';
+/**
+ * Connection options for `MilvusStore`. Passed straight through to
+ * `@zilliz/milvus2-sdk-node`'s `MilvusClient` (address, auth, TLS,
+ * per-request timeout, gRPC channel options, etc).
+ */
+export type MilvusStoreOptions = ClientConfig;
+/** A single field in a collection's schema, as accepted by `createCollection()`. */
+export interface MilvusFieldDefinition {
+    name: string;
+    data_type: DataType;
+    /** Vector dimension. Required for `FloatVector`/`BinaryVector`/etc fields. */
+    dim?: number;
+    is_primary_key?: boolean;
+    /** Server-generated auto-incrementing primary key (only valid on the primary key field). */
+    autoID?: boolean;
+    is_partition_key?: boolean;
+    /** `VarChar` max length. */
+    max_length?: number;
+    description?: string;
+}
+/** Options for `createCollection()`. */
+export interface CreateCollectionOptions {
+    description?: string;
+    /** Number of shards. Defaults to the server's default (1) if omitted. */
+    shardsNum?: number;
+    consistencyLevel?: ConsistencyLevelEnum | 'Strong' | 'Session' | 'Bounded' | 'Eventually' | 'Customized';
+    enableDynamicField?: boolean;
+}
+/** A `CREATE INDEX`-equivalent request for `createIndex()`. */
+export interface CreateIndexOptions {
+    fieldName: string;
+    indexType: string;
+    metricType?: string;
+    indexName?: string;
+    params?: Record<string, string | number | boolean>;
+}
+/** Result of a `describeIndex()`/`listIndexes()` call. */
+export interface MilvusIndexInfo {
+    indexName: string;
+    fieldName: string;
+    indexType?: string;
+    metricType?: string;
+    state: string;
+    indexedRows: string;
+    totalRows: string;
+}
+/** Options shared by `insert()`/`upsert()`. */
+export interface WriteOptions {
+    partitionName?: string;
+}
+/** Options for `search()`. */
+export interface SearchOptions {
+    /**
+     * The query vector to search for. Only a single query vector is
+     * supported per call - Milvus's underlying API also accepts a batch
+     * (`number[][]`) that returns one result set per query vector, but that
+     * shape isn't wrapped here; use `getClient().search(...)` directly for
+     * batched multi-vector search.
+     */
+    vector: number[];
+    /** Name of the vector field to search. Required if the collection has more than one vector field. */
+    annsField?: string;
+    /** Max number of nearest neighbors to return per query vector. */
+    limit?: number;
+    /** Scalar filter expression narrowing candidates before/while ranking (Milvus's boolean expression language, e.g. `'age > 21 && category == "b"'`). */
+    filter?: string;
+    outputFields?: string[];
+    partitionNames?: string[];
+    metricType?: string;
+    offset?: number;
+}
+/** Options for `query()`. */
+export interface QueryOptions {
+    /** Scalar filter expression. Omit (with `ids`) to fetch by primary key instead. */
+    filter?: string;
+    ids?: (string | number)[];
+    outputFields?: string[];
+    partitionNames?: string[];
+    limit?: number;
+    offset?: number;
+}
+/** Result row of a `search()` call. */
+export interface MilvusSearchHit {
+    id: string | number;
+    score: number;
+    [field: string]: unknown;
+}
+/**
+ * `MilvusStore` wraps `@zilliz/milvus2-sdk-node`'s `MilvusClient` and exposes
+ * Milvus's collection/index/data/partition operations as a typed,
+ * promise-based API.
+ */
+export declare class MilvusStore implements NoSqlStore {
+    readonly name = "milvus";
+    readonly library = "@zilliz/milvus2-sdk-node";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options: MilvusStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `MilvusClient` for anything not wrapped here. */
+    getClient(): MilvusClient;
+    private requireClient;
+    private exec;
+    /** Create a collection with an explicit field schema (primary key + one or more vector fields + optional scalars). */
+    createCollection(collectionName: string, fields: MilvusFieldDefinition[], options?: CreateCollectionOptions): Promise<void>;
+    dropCollection(collectionName: string): Promise<void>;
+    hasCollection(collectionName: string): Promise<boolean>;
+    describeCollection(collectionName: string): Promise<DescribeCollectionResponse>;
+    /** List all collections. */
+    listCollections(): Promise<CollectionData[]>;
+    /** Load a collection's data into query nodes' memory so it can be searched/queried. */
+    loadCollection(collectionName: string, replicaNumber?: number): Promise<void>;
+    /** Release a collection's data from memory (it remains persisted; reload with `loadCollection()` to search it again). */
+    releaseCollection(collectionName: string): Promise<void>;
+    getCollectionStatistics(collectionName: string): Promise<Record<string, unknown>>;
+    createIndex(collectionName: string, options: CreateIndexOptions): Promise<void>;
+    dropIndex(collectionName: string, fieldName?: string, indexName?: string): Promise<void>;
+    describeIndex(collectionName: string, fieldName?: string): Promise<MilvusIndexInfo[]>;
+    listIndexes(collectionName: string): Promise<string[]>;
+    insert(collectionName: string, rows: RowData[], options?: WriteOptions): Promise<MutationResult>;
+    upsert(collectionName: string, rows: RowData[], options?: WriteOptions): Promise<MutationResult>;
+    /**
+     * Approximate-nearest-neighbor search against a vector field. Ranks by
+     * the collection's index metric (`L2`/`IP`/`COSINE`/...), optionally
+     * narrowed by a scalar `filter` expression evaluated alongside the
+     * vector comparison.
+     */
+    search(collectionName: string, options: SearchOptions): Promise<MilvusSearchHit[]>;
+    /** Scalar-only lookup (no vector similarity) via a filter expression and/or primary key list. */
+    query(collectionName: string, options?: QueryOptions): Promise<Record<string, unknown>[]>;
+    /** Fetch specific rows by primary key. Equivalent to `query()` with `ids` set, using Milvus's dedicated `Get` RPC. */
+    get(collectionName: string, ids: (string | number)[], outputFields?: string[]): Promise<Record<string, unknown>[]>;
+    /** Count rows matching an optional filter expression (all rows if omitted). */
+    count(collectionName: string, filter?: string): Promise<number>;
+    deleteByIds(collectionName: string, ids: (string | number)[], partitionName?: string): Promise<MutationResult>;
+    deleteByFilter(collectionName: string, filter: string, partitionName?: string): Promise<MutationResult>;
+    createPartition(collectionName: string, partitionName: string): Promise<void>;
+    dropPartition(collectionName: string, partitionName: string): Promise<void>;
+    hasPartition(collectionName: string, partitionName: string): Promise<boolean>;
+    listPartitions(collectionName: string): Promise<string[]>;
+    loadPartitions(collectionName: string, partitionNames: string[], replicaNumber?: number): Promise<void>;
+    releasePartitions(collectionName: string, partitionNames: string[]): Promise<void>;
+    getPartitionStatistics(collectionName: string, partitionName: string): Promise<Record<string, unknown>>;
+}
+export default MilvusStore;