ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,80 @@
+/**
+ * Apache Ignite store implementation.
+ *
+ * Apache Ignite is a distributed in-memory data grid / database. Data lives
+ * in distributed key/value caches partitioned across cluster nodes, accessed
+ * here via Ignite's thin-client protocol. Although Ignite also speaks SQL,
+ * this store targets its distributed-cache (key/value grid) surface, which
+ * does not fit the SQL-shaped `Dialect` interface, so it implements the
+ * minimal `NoSqlStore` marker interface and exposes cache operations
+ * (getCache/put/get/removeKey/getKeys/getSize) as a typed, promise-based API.
+ *
+ * Uses the `apache-ignite-client` driver (the official Node.js thin client).
+ * The driver is loaded lazily inside `connect()` (or supplied pre-built via
+ * the `client` option) so importing this module never requires
+ * `apache-ignite-client` to be installed unless an Ignite store is actually
+ * connected. Tests inject a mock client this way.
+ */
+import { NoSqlStore } from '../store';
+/** The subset of an Ignite thin-client `CacheClient` this store drives. */
+export interface IgniteCache {
+    put(key: unknown, value: unknown): Promise<unknown>;
+    get(key: unknown): Promise<unknown>;
+    removeKey(key: unknown): Promise<boolean>;
+    getKeys(): Promise<unknown[]>;
+    getSize(): Promise<number>;
+}
+/** The subset of the `apache-ignite-client` `IgniteClient` surface this store drives. */
+export interface IgniteClientLike {
+    connect(config: unknown): Promise<void>;
+    disconnect(): void | Promise<void>;
+    getCache(name: string): IgniteCache | Promise<IgniteCache>;
+}
+/** Connection options for `IgniteStore`. */
+export interface IgniteStoreOptions {
+    /**
+     * One or more `host:port` thin-client endpoints (default
+     * `['127.0.0.1:10800']`). Passed to `new IgniteClientConfiguration(...)`.
+     * Ignored when a pre-built `client` is supplied.
+     */
+    endpoints?: string[];
+    /** Pre-built Ignite client; when given, `connect()` uses it and skips `require('apache-ignite-client')`. */
+    client?: IgniteClientLike;
+}
+/** Slug + human label for error/message context. Shared with `GridGainStore`. */
+export declare const IGNITE_DB = "ignite";
+/**
+ * `IgniteStore` wraps an `apache-ignite-client` `IgniteClient` and exposes
+ * its distributed-cache operations as a typed, promise-based API.
+ */
+export declare class IgniteStore implements NoSqlStore {
+    readonly name = "ignite";
+    readonly library = "apache-ignite-client";
+    protected readonly database = "ignite";
+    protected readonly label = "Ignite";
+    private readonly options;
+    private client;
+    private connected;
+    /** Resolved `CacheClient` handles, cached by name so `getMap` is idempotent. */
+    private readonly caches;
+    constructor(options?: IgniteStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `apache-ignite-client` client for anything not wrapped here. */
+    getClient(): IgniteClientLike;
+    private requireClient;
+    /** Resolve (and cache) a distributed cache handle by name. */
+    getMap(name: string): Promise<IgniteCache>;
+    /** Put `value` under `key` in `map` (an Ignite cache handle). */
+    mapPut(map: IgniteCache, key: unknown, value: unknown): Promise<unknown>;
+    /** Get the value stored under `key` in `map` (or null if absent). */
+    mapGet(map: IgniteCache, key: unknown): Promise<unknown>;
+    /** Remove `key` from `map`. Returns Ignite's boolean success flag. */
+    mapRemove(map: IgniteCache, key: unknown): Promise<boolean>;
+    /** Return all keys currently in `map` as an array. */
+    mapKeys(map: IgniteCache): Promise<unknown[]>;
+    /** Return the number of entries in `map`. */
+    mapSize(map: IgniteCache): Promise<number>;
+}
+export default IgniteStore;

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

@@ -0,0 +1,131 @@
+/**
+ * immudb store implementation.
+ *
+ * immudb is an immutable, append-only key-value (and SQL) database with
+ * built-in cryptographic verification: every write is added to a tamper-
+ * evident Merkle-tree-backed log, and `verifiedSet`/`verifiedGet` return an
+ * inclusion/consistency proof the client checks locally, so a compromised
+ * server cannot lie about stored data without detection.
+ *
+ * immudb is a key-value ledger, not a SQL `Dialect`, so this class implements
+ * the minimal `NoSqlStore` marker interface plus the shared ledger surface
+ * (`append`/`get`/`history`/`verify`/`query`). Because immudb addresses
+ * records by key rather than by (table, row), `append`/`get`/`history`/
+ * `verify` treat their first argument as a key namespace and compose the
+ * immudb key as `<table>:<id>` (or just `<table>` when no id is given).
+ * `query` maps to immudb's embedded SQL engine (`sqlQuery`/`sqlExec`).
+ *
+ * ## Lazy driver loading
+ *
+ * The `immudb-node` package is loaded lazily inside `connect()`; importing
+ * this module never requires it. Tests inject a pre-built, already-logged-in
+ * client via `ImmudbStoreOptions.client`, bypassing the `require`.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * The subset of an `immudb-node` client this store uses. The real client
+ * implements this; tests inject a mock with the same shape.
+ */
+export interface ImmudbClientLike {
+    login?(opts: {
+        user: string;
+        password: string;
+    }): Promise<unknown>;
+    useDatabase?(opts: {
+        databasename: string;
+    }): Promise<unknown>;
+    /** Non-verified write. Returns transaction metadata (id/hash). */
+    set(opts: {
+        key: string;
+        value: string;
+    }): Promise<any>;
+    /** Non-verified read. */
+    get(opts: {
+        key: string;
+    }): Promise<any>;
+    /** Verified write - the response includes a cryptographic proof. */
+    verifiedSet(opts: {
+        key: string;
+        value: string;
+    }): Promise<any>;
+    /** Verified read - the response includes a cryptographic proof. */
+    verifiedGet(opts: {
+        key: string;
+    }): Promise<any>;
+    /** Prior revisions of a key. */
+    history(opts: {
+        key: string;
+    }): Promise<any>;
+    /** Execute a SQL statement (DDL/DML) against immudb's embedded SQL engine. */
+    sqlExec?(opts: {
+        sql: string;
+        params?: unknown;
+    }): Promise<any>;
+    /** Run a SQL query and return rows. */
+    sqlQuery?(opts: {
+        sql: string;
+        params?: unknown;
+    }): Promise<any>;
+    close?(): Promise<void> | void;
+    shutdown?(): Promise<void> | void;
+}
+/** Connection options for `ImmudbStore`. */
+export interface ImmudbStoreOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    /**
+     * A pre-built client to use instead of the lazy `require`. When provided,
+     * `connect()` uses it verbatim (and skips `login`/`useDatabase`).
+     */
+    client?: ImmudbClientLike;
+}
+/**
+ * `ImmudbStore` wraps an `immudb-node` client behind the shared ledger
+ * surface. `append` performs a `verifiedSet` (returning the write's
+ * transaction id), `get` a `verifiedGet`, `history` returns prior revisions
+ * of a key, `verify` returns the full verified-read response (value + proof),
+ * and `query` runs embedded SQL via `sqlQuery`.
+ */
+export declare class ImmudbStore implements NoSqlStore {
+    readonly name = "immudb";
+    readonly library = "immudb-node";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: ImmudbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `immudb-node` client for anything not wrapped here. */
+    getClient(): ImmudbClientLike;
+    private requireClient;
+    /** Compose the immudb key from a (table, id) address. */
+    private keyFor;
+    private encode;
+    private run;
+    /**
+     * Append `data` under the key `<table>:<data.id>` (or `<table>` if `data`
+     * has no `id`) via a verified, tamper-evident write. Returns the write's
+     * transaction id/hash from immudb's response.
+     */
+    append(table: string, data: unknown): Promise<string>;
+    /** Verified read of the current value at `<table>:<id>` (or `<table>`). */
+    get(table: string, id?: string): Promise<unknown>;
+    /** Return every prior revision of the key `<table>:<id>` (or `<table>`). */
+    history(table: string, id?: string): Promise<unknown>;
+    /**
+     * Verified read returning the full response - value plus the cryptographic
+     * inclusion proof immudb generates for `verifiedGet`. The presence of a
+     * resolved response (rather than a thrown verification error) is the proof
+     * that the value is consistent with the tamper-evident log.
+     */
+    verify(table: string, id?: string): Promise<unknown>;
+    /** Run a SQL `statement` against immudb's embedded SQL engine (`sqlQuery`). */
+    query(statement: string, params?: unknown): Promise<unknown>;
+    /** Execute a SQL DDL/DML `statement` via `sqlExec` (no rows returned). */
+    exec(statement: string, params?: unknown): Promise<unknown>;
+}
+export default ImmudbStore;

package/dist/nosql/index.d.ts

@@ -0,0 +1,215 @@
+/**
+ * NoSQL store implementations.
+ *
+ * Unlike the SQL dialects (src/dialects/**), these do not share a common
+ * query-shaped interface — a document store, a key-value cache, and a
+ * partition-key store each expose a different API. `NoSqlStore` is only
+ * the minimal shared connection-lifecycle contract; see each store's own
+ * class and README for its real capabilities.
+ */
+export type { NoSqlStore } from './store';
+export { MongoStore } from './mongodb';
+export type { MongoStoreOptions, MongoFindOptions } from './mongodb';
+export { RedisStore } from './redis';
+export type { SetOptions, ZMember, ZRangeOptions } from './redis';
+export { DynamoDbStore, DynamoReturnValues, DynamoStreamViewType } from './dynamodb';
+export type { DynamoDbStoreOptions, PutItemOptions, UpdateItemOptions, DeleteItemOptions, QueryParams, QueryResult as DynamoQueryResult, ScanParams, } from './dynamodb';
+export { PineconeStore } from './pinecone';
+export type { PineconeStoreOptions, CreateIndexOptions as PineconeCreateIndexOptions, VectorRecord, UpsertVectorsOptions, QueryVectorsOptions, FetchVectorsOptions, DeleteByIdsOptions as PineconeDeleteByIdsOptions, DeleteByFilterOptions as PineconeDeleteByFilterOptions, DeleteAllVectorsOptions, UpdateVectorOptions, DescribeIndexStatsOptions, } from './pinecone';
+export { PineconeErrors } from './pinecone';
+export { MilvusStore } from './milvus';
+export type { MilvusStoreOptions, MilvusFieldDefinition, CreateCollectionOptions as MilvusCreateCollectionOptions, CreateIndexOptions as MilvusCreateIndexOptions, MilvusIndexInfo, WriteOptions as MilvusWriteOptions, SearchOptions as MilvusSearchOptions, QueryOptions as MilvusQueryOptions, MilvusSearchHit, } from './milvus';
+export { QdrantStore } from './qdrant';
+export type { QdrantStoreOptions, VectorParams, Distance, VectorsConfig, PointStruct, Filter as QdrantFilter, Condition as QdrantCondition, ScoredPoint, PointRecord, CollectionInfo as QdrantCollectionInfo, CollectionDescription as QdrantCollectionDescription, UpdateResult as QdrantUpdateResult, WithPayload, WithVectorOption, PointId, PointsSelector, Payload, CountResult as QdrantCountResult, CollectionAliasesResponse, WriteOrdering, ReadConsistency, PayloadFieldSchema, Batch as QdrantBatch, WriteOptions as QdrantWriteOptions, ReadOptions as QdrantReadOptions, CreateCollectionOptions as QdrantCreateCollectionOptions, SearchOptions as QdrantSearchOptions, ScrollOptions, ScrollPage, RetrieveOptions, } from './qdrant';
+export { WeaviateStore } from './weaviate';
+export type { WeaviateStoreOptions, WeaviateProperty, WeaviateVectorizerConfig, WeaviateCreateCollectionOptions, WeaviateInsertObject, WeaviateBatchObject, WeaviateUpdateFields, WeaviateReplaceFields, WeaviateNearOptions, WeaviateNearTextOptions, WeaviateFetchObjectsOptions, WeaviateFetchObjectByIdOptions, WeaviateResultObject, WeaviateQueryReturn, WeaviateFilterValue, WeaviateBatchInsertResult, WeaviateDeleteManyResult, WeaviateVectorInput, } from './weaviate';
+export { Neo4jStore, intToNumber } from './neo4j';
+export type { Neo4jStoreOptions, CypherParams, SessionOptions as Neo4jSessionOptions, CypherSummary, CypherResult, GraphNode, GraphRelationship, FindOptions as Neo4jFindOptions, DeleteNodeOptions, Neo4jTransaction, } from './neo4j';
+export { ArangoStore } from './arangodb';
+export type { ArangoStoreOptions, ArangoCollectionOptions, ArangoIndexType, CreateIndexOptions as ArangoCreateIndexOptions, TraverseDirection, TraverseOptions, TraversalResult, } from './arangodb';
+export { TigerGraphStore } from './tigergraph';
+export type { TigerGraphStoreOptions, AttributeValue as TigerGraphAttributeValue, PlainAttributes, WireAttributes, UpsertPayload, EdgeUpsert, TigerGraphVertex, TigerGraphEdge, VertexTypeSchema, EdgeTypeSchema, RunQueryOptions, InterpretedQueryOptions, ListVerticesOptions, } from './tigergraph';
+export { NeptuneStore, NeptuneError } from './neptune';
+export type { NeptuneStoreOptions, ElementQueryOptions, NeighborOptions, NeptuneId, NeptuneDirection, NeptuneAuthHeaderProvider, NeptuneVertex, NeptuneEdge, } from './neptune';
+export { ElasticsearchStore, isElasticsearchNotFoundError, isElasticsearchConflictError } from './elasticsearch';
+export type { ElasticsearchStoreOptions, CreateIndexOptions as ElasticsearchCreateIndexOptions, IndexDocumentOptions, UpdateDocumentOptions, DeleteDocumentOptions, BulkAction, BulkItemResult, BulkResult, SearchParams, SearchHit, SearchResult, } from './elasticsearch';
+export { InfluxDBStore, Point } from './influxdb';
+export type { InfluxDBStoreOptions, WriteScopeOptions, QueryScopeOptions, PointInput, QueryRow, WriteApi as InfluxWriteApi, QueryApi as InfluxQueryApi, WriteOptions as InfluxWriteOptions, WritePrecisionType, Row as InfluxRow, FluxTableMetaData, ParameterizedQuery, } from './influxdb';
+export { EtcdStore } from './etcd';
+export type { EtcdStoreOptions, EtcdTlsOptions, EtcdAuthOptions, PutOptions as EtcdPutOptions, GrantLeaseOptions, EtcdWatchEvent, EtcdWatchHandle, EtcdLockHandle, } from './etcd';
+export { S3Store } from './s3';
+export type { S3StoreOptions } from './s3';
+export { GCSStore } from './gcs';
+export type { GCSStoreOptions } from './gcs';
+export { AzureBlobStore } from './azure-blob';
+export type { AzureBlobStoreOptions } from './azure-blob';
+export { KafkaStore } from './kafka';
+export type { KafkaStoreOptions } from './kafka';
+export { NatsStore } from './nats';
+export type { NatsStoreOptions } from './nats';
+export { RabbitMQStore } from './rabbitmq';
+export type { RabbitMQStoreOptions } from './rabbitmq';
+export { CassandraStore } from './cassandra';
+export type { CassandraStoreOptions } from './cassandra';
+export { CouchbaseStore } from './couchbase';
+export type { CouchbaseStoreOptions } from './couchbase';
+export { MemcachedStore } from './memcached';
+export type { MemcachedStoreOptions } from './memcached';
+export { SurrealStore } from './surrealdb';
+export type { SurrealStoreOptions } from './surrealdb';
+export { OpenSearchStore } from './opensearch';
+export type { OpenSearchStoreOptions } from './opensearch';
+export { RethinkDBStore } from './rethinkdb';
+export type { RethinkDBStoreOptions } from './rethinkdb';
+export { ScyllaStore } from './scylladb';
+export type { ScyllaStoreOptions } from './scylladb';
+export { KeyspacesStore } from './keyspaces';
+export type { KeyspacesStoreOptions } from './keyspaces';
+export { HBaseStore } from './hbase';
+export type { HBaseStoreOptions } from './hbase';
+export { BigtableStore } from './bigtable';
+export type { BigtableStoreOptions } from './bigtable';
+export { MeilisearchStore } from './meilisearch';
+export type { MeilisearchStoreOptions } from './meilisearch';
+export { TypesenseStore } from './typesense';
+export type { TypesenseStoreOptions } from './typesense';
+export { SolrStore } from './solr';
+export type { SolrStoreOptions } from './solr';
+export { ChromaStore } from './chroma';
+export type { ChromaStoreOptions } from './chroma';
+export { PrometheusStore } from './prometheus';
+export type { PrometheusStoreOptions } from './prometheus';
+export { VictoriaMetricsStore } from './victoriametrics';
+export type { VictoriaMetricsStoreOptions } from './victoriametrics';
+export { MinioStore } from './minio';
+export type { MinioStoreOptions } from './minio';
+export { R2Store } from './r2';
+export type { R2StoreOptions } from './r2';
+export { PulsarStore } from './pulsar';
+export type { PulsarStoreOptions } from './pulsar';
+export { RedpandaStore } from './redpanda';
+export type { RedpandaStoreOptions } from './redpanda';
+export { AerospikeStore } from './aerospike';
+export type { AerospikeStoreOptions } from './aerospike';
+export { DgraphStore } from './dgraph';
+export type { DgraphStoreOptions } from './dgraph';
+export { HazelcastStore } from './hazelcast';
+export type { HazelcastStoreOptions } from './hazelcast';
+export { IgniteStore } from './ignite';
+export type { IgniteStoreOptions } from './ignite';
+export { GridGainStore } from './gridgain';
+export type { GridGainStoreOptions } from './gridgain';
+export { InfinispanStore } from './infinispan';
+export type { InfinispanStoreOptions } from './infinispan';
+export { GeodeStore } from './geode';
+export type { GeodeStoreOptions } from './geode';
+export { CoherenceStore } from './coherence';
+export type { CoherenceStoreOptions } from './coherence';
+export { RocksDBStore } from './rocksdb';
+export type { RocksDBStoreOptions } from './rocksdb';
+export { LevelDBStore } from './leveldb';
+export type { LevelDBStoreOptions } from './leveldb';
+export { LmdbStore } from './lmdb';
+export type { LmdbStoreOptions } from './lmdb';
+export { UnqliteStore } from './unqlite';
+export type { UnqliteStoreOptions } from './unqlite';
+export { NedbStore } from './nedb';
+export type { NedbStoreOptions } from './nedb';
+export { PouchdbStore } from './pouchdb';
+export type { PouchdbStoreOptions } from './pouchdb';
+export { QldbStore } from './qldb';
+export type { QldbStoreOptions } from './qldb';
+export { ImmudbStore } from './immudb';
+export type { ImmudbStoreOptions } from './immudb';
+export { BigchaindbStore } from './bigchaindb';
+export type { BigchaindbStoreOptions } from './bigchaindb';
+export { TerminusdbStore } from './terminusdb';
+export type { TerminusdbStoreOptions } from './terminusdb';
+export { FlureeStore } from './fluree';
+export type { FlureeStoreOptions } from './fluree';
+export { ProvendbStore } from './provendb';
+export type { ProvendbStoreOptions } from './provendb';
+export { CosmosDbStore } from './cosmosdb';
+export type { CosmosDbStoreOptions } from './cosmosdb';
+export { FaunaDbStore } from './faunadb';
+export type { FaunaDbStoreOptions } from './faunadb';
+export { OrientDbStore } from './orientdb';
+export type { OrientDbStoreOptions } from './orientdb';
+export { MarkLogicStore } from './marklogic';
+export type { MarkLogicStoreOptions } from './marklogic';
+export { FirestoreStore } from './firestore';
+export type { FirestoreStoreOptions } from './firestore';
+export { RavenDbStore } from './ravendb';
+export type { RavenDbStoreOptions } from './ravendb';
+export { FusekiStore } from './fuseki';
+export type { FusekiStoreOptions } from './fuseki';
+export { GraphdbStore } from './graphdb';
+export type { GraphdbStoreOptions } from './graphdb';
+export { StardogStore } from './stardog';
+export type { StardogStoreOptions } from './stardog';
+export { BlazegraphStore } from './blazegraph';
+export type { BlazegraphStoreOptions } from './blazegraph';
+export { VirtuosoStore } from './virtuoso';
+export type { VirtuosoStoreOptions } from './virtuoso';
+export { AllegrographStore } from './allegrograph';
+export type { AllegrographStoreOptions } from './allegrograph';
+export { DruidStore } from './druid';
+export type { DruidStoreOptions } from './druid';
+export { PinotStore } from './pinot';
+export type { PinotStoreOptions } from './pinot';
+export { StarrocksStore } from './starrocks';
+export type { StarrocksStoreOptions } from './starrocks';
+export { DorisStore } from './doris';
+export type { DorisStoreOptions } from './doris';
+export { RocksetStore } from './rockset';
+export type { RocksetStoreOptions } from './rockset';
+export { MaterializeStore } from './materialize';
+export type { MaterializeStoreOptions } from './materialize';
+export { KinesisStore } from './kinesis';
+export type { KinesisStoreOptions } from './kinesis';
+export { EventHubsStore } from './eventhubs';
+export type { EventHubsStoreOptions } from './eventhubs';
+export { PubSubStore } from './pubsub';
+export type { PubSubStoreOptions } from './pubsub';
+export { SqsStore } from './sqs';
+export type { SqsStoreOptions } from './sqs';
+export { SnsStore } from './sns';
+export type { SnsStoreOptions } from './sns';
+export { EventStoreStore } from './eventstore';
+export type { EventStoreStoreOptions } from './eventstore';
+export { CloudflareKvStore } from './cloudflare-kv';
+export type { CloudflareKvSetOptions } from './cloudflare-kv';
+export { VercelKvStore } from './vercel-kv';
+export type { VercelKvSetOptions } from './vercel-kv';
+export { UpstashStore } from './upstash';
+export type { UpstashSetOptions } from './upstash';
+export { DenoKvStore } from './deno-kv';
+export type { DenoKvSetOptions } from './deno-kv';
+export { MomentoStore } from './momento';
+export type { MomentoSetOptions } from './momento';
+export { DaxStore } from './dax';
+export type { DaxSetOptions } from './dax';
+export { BeanstalkdStore } from './beanstalkd';
+export type { BeanstalkdStoreOptions } from './beanstalkd';
+export { GearmanStore } from './gearman';
+export type { GearmanStoreOptions } from './gearman';
+export { BullMQStore } from './bullmq';
+export type { BullMQStoreOptions } from './bullmq';
+export { NsqStore } from './nsq';
+export type { NsqStoreOptions } from './nsq';
+export { ResqueStore } from './resque';
+export type { ResqueStoreOptions } from './resque';
+export { BeeQueueStore } from './beequeue';
+export type { BeeQueueStoreOptions } from './beequeue';
+export { LokiStore } from './loki';
+export type { LokiStoreOptions } from './loki';
+export { SplunkStore } from './splunk';
+export type { SplunkStoreOptions } from './splunk';
+export { GraylogStore } from './graylog';
+export type { GraylogStoreOptions } from './graylog';
+export { SumoLogicStore } from './sumologic';
+export type { SumoLogicStoreOptions } from './sumologic';
+export { SigNozStore } from './signoz';
+export type { SigNozStoreOptions } from './signoz';
+export { PapertrailStore } from './papertrail';
+export type { PapertrailStoreOptions } from './papertrail';

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

@@ -0,0 +1,95 @@
+/**
+ * Infinispan store implementation.
+ *
+ * Infinispan is a distributed in-memory key/value data grid. Data lives in
+ * named caches; there is no SQL-shaped `query(sql)` surface, so this class
+ * implements the minimal `NoSqlStore` marker interface and exposes
+ * Infinispan's distributed-cache operations
+ * (getMap/put/get/remove/keys/size) as a typed, promise-based API.
+ *
+ * ## Transport: the Infinispan REST API over `fetch` (not the node driver)
+ *
+ * Infinispan does publish an `infinispan` npm client, but that driver binds
+ * a client to a *single* cache at connect time (`client.get/put/remove`) and
+ * offers no per-name `getMap`. That does not map onto this store's common
+ * surface, where `getMap(name)` must resolve an arbitrary named cache. The
+ * Infinispan REST API does map cleanly - every cache/key is addressable as
+ * `/rest/v2/caches/<cache>/<key>` - so this store talks REST over the global
+ * `fetch`, exactly like `PrometheusStore`. For tests (and callers who want
+ * their own transport) an alternative client can be injected via
+ * `InfinispanStoreOptions.client`; when omitted, a tiny internal `fetch`
+ * client is built at connect time. `library` is therefore `'fetch'`.
+ *
+ * Endpoints wrapped:
+ * - `mapPut`    -> `PUT    /rest/v2/caches/<cache>/<key>`
+ * - `mapGet`    -> `GET    /rest/v2/caches/<cache>/<key>`
+ * - `mapRemove` -> `DELETE /rest/v2/caches/<cache>/<key>`
+ * - `mapKeys`   -> `GET    /rest/v2/caches/<cache>?action=keys`
+ * - `mapSize`   -> `GET    /rest/v2/caches/<cache>?action=size`
+ */
+import { NoSqlStore } from '../store';
+/** Default Infinispan REST base URL. */
+export declare const DEFAULT_INFINISPAN_BASE_URL = "http://localhost:11222";
+/**
+ * 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 InfinispanHttpClient {
+    /** GET `path`; return the parsed body, or `null` on 404. */
+    get(path: string): Promise<any>;
+    /** PUT `body` to `path`. */
+    put(path: string, body: string, contentType?: string): Promise<any>;
+    /** DELETE `path`. */
+    delete(path: string): Promise<any>;
+}
+/** A resolved cache handle. `getMap(name)` returns one; the `map*` methods consume it. */
+export interface InfinispanMap {
+    readonly name: string;
+}
+/** Connection options for `InfinispanStore`. */
+export interface InfinispanStoreOptions {
+    /** Base URL of the Infinispan server. Defaults to `http://localhost:11222`. */
+    baseURL?: string;
+    /** Pre-built HTTP client; when given it is used verbatim and `baseURL` is ignored. */
+    client?: InfinispanHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed REST client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): InfinispanHttpClient;
+/**
+ * `InfinispanStore` wraps Infinispan's REST API behind the `NoSqlStore`
+ * lifecycle and exposes named-cache key/value operations.
+ */
+export declare class InfinispanStore implements NoSqlStore {
+    readonly name = "infinispan";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    /** Cached cache handles, keyed by name so `getMap` is idempotent. */
+    private readonly maps;
+    constructor(options?: InfinispanStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): InfinispanHttpClient;
+    private requireClient;
+    private wrap;
+    /** Resolve (and cache) a named-cache handle. */
+    getMap(name: string): Promise<InfinispanMap>;
+    /** Store `value` under `key` in `map` (`PUT /rest/v2/caches/<cache>/<key>`). */
+    mapPut(map: InfinispanMap, key: string, value: unknown): Promise<void>;
+    /** Read `key` from `map` (`GET /rest/v2/caches/<cache>/<key>`); `null` if absent. */
+    mapGet(map: InfinispanMap, key: string): Promise<any>;
+    /** Remove `key` from `map` (`DELETE /rest/v2/caches/<cache>/<key>`). */
+    mapRemove(map: InfinispanMap, key: string): Promise<any>;
+    /** List all keys in `map` (`GET /rest/v2/caches/<cache>?action=keys`). */
+    mapKeys(map: InfinispanMap): Promise<any[]>;
+    /** Number of entries in `map` (`GET /rest/v2/caches/<cache>?action=size`). */
+    mapSize(map: InfinispanMap): Promise<number>;
+}
+export default InfinispanStore;

package/dist/nosql/influxdb/flux-compiler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compiles the ORM `where`/`order` shape into Flux, so callers read InfluxDB
+ * through the model API instead of hand-writing Flux for standard queries.
+ *
+ * The generated predicate references the *pivoted* row (`r.<column>`), i.e. it
+ * is applied after `pivot()` folds each measurement's fields into columns, so a
+ * single predicate can mix tag columns and field columns uniformly. Operators
+ * Flux cannot express are surfaced as {@link FluxPushdownUnsupported}, which
+ * the store catches to fall back to collecting rows and filtering them in
+ * memory with the shared matcher - the read still succeeds.
+ */
+import type { WhereClause, OrderSpec } from '../rocksdb/where-match';
+/** Thrown when a where clause cannot be fully translated to a Flux predicate. */
+export declare class FluxPushdownUnsupported extends Error {
+    constructor(message: string);
+}
+/** Compile a where clause to a Flux `filter(fn: (r) => ...)` predicate body. */
+export declare function compileFluxPredicate(where: WhereClause): string;
+/** Compile an `order` spec to Flux `sort()` args: `columns: [...], desc: bool`. */
+export declare function compileFluxSort(order: OrderSpec): {
+    columns: string[];
+    desc: boolean;
+};