ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,120 @@
+/**
+ * Papertrail store implementation.
+ *
+ * Papertrail (by SolarWinds) is a hosted log-management service. Logs are
+ * ingested over syslog or an HTTP log destination, and searched via the REST
+ * events API. There is no SQL-shaped query surface, no row-level
+ * UPDATE/DELETE, and no identifier escaping, so Papertrail 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 Papertrail's ingest/search API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Papertrail has no single canonical npm client; it is an HTTP/JSON API
+ * (`X-Papertrail-Token` auth). 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 `PapertrailStoreOptions.client`.
+ *
+ * Search targets the REST API (`apiURL`); ingest targets the configured HTTP
+ * log destination (`ingestURL`). The internal client resolves absolute URLs
+ * verbatim, so `push()` posts to the full ingest URL while search/metadata
+ * methods use relative API paths.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(lines)`     -> `POST <ingestURL>`          (HTTP/syslog ingest)
+ * - `query(q, opts?)` -> `GET  /api/v1/events/search` (search events)
+ * - `labels()`        -> `GET  /api/v1/groups`        (log groups)
+ * - `streams()`       -> `GET  /api/v1/systems`       (systems/senders)
+ */
+import { NoSqlStore } from '../store';
+/** Default Papertrail REST API base URL. */
+export declare const DEFAULT_PAPERTRAIL_API_URL = "https://papertrailapp.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 PapertrailHttpClient {
+    /** 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 `PapertrailStore`. */
+export interface PapertrailStoreOptions {
+    /** Base URL of the Papertrail REST API. Defaults to `https://papertrailapp.com`. */
+    apiURL?: string;
+    /** Full HTTP log-destination URL that `push()` ingests to. */
+    ingestURL?: string;
+    /** Papertrail API token, sent as `X-Papertrail-Token`. */
+    token?: 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?: PapertrailHttpClient;
+    /** Extra HTTP headers sent with every request. */
+    headers?: Record<string, string>;
+}
+/** Options for an events search. */
+export interface PapertrailQueryOptions {
+    /** Restrict the search to a single system ID. */
+    systemId?: string | number;
+    /** Restrict the search to a single group ID. */
+    groupId?: string | number;
+    /** Return events with IDs greater than this (pagination forward). */
+    minId?: string;
+    /** Return events with IDs less than this (pagination backward). */
+    maxId?: string;
+    /** Return events at or after this Unix time. */
+    minTime?: string | number;
+    /** Return events at or before this Unix time. */
+    maxTime?: string | number;
+    /** Number of events to return. */
+    limit?: number;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): PapertrailHttpClient;
+/**
+ * `PapertrailStore` wraps Papertrail's HTTP log-destination ingest and its
+ * REST events-search API (plus group/system metadata) behind the
+ * `NoSqlStore` lifecycle.
+ */
+export declare class PapertrailStore implements NoSqlStore {
+    readonly name = "papertrail";
+    readonly library = "fetch";
+    private readonly apiURL;
+    private readonly ingestURL?;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: PapertrailStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): PapertrailHttpClient;
+    private requireClient;
+    private doGet;
+    /**
+     * Ingests raw log lines by POSTing them (newline-delimited) to the
+     * configured HTTP log-destination `ingestURL`. Accepts a single string or
+     * an array of lines (joined with newlines).
+     */
+    push(lines: string | string[]): Promise<any>;
+    /**
+     * Searches log events via `GET /api/v1/events/search`. Returns the parsed
+     * response (`{ events, min_id, max_id, reached_beginning, ... }`).
+     */
+    query(q: string, options?: PapertrailQueryOptions): Promise<any>;
+    /** Lists the configured log groups via `GET /api/v1/groups`. */
+    labels(): Promise<any>;
+    /** Lists the configured systems (log senders) via `GET /api/v1/systems`. */
+    streams(): Promise<any>;
+}
+export default PapertrailStore;

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

@@ -0,0 +1,148 @@
+/**
+ * Pinecone vector-database store.
+ *
+ * Pinecone is a managed vector database: records are `{ id, values, metadata }`
+ * tuples (an embedding vector plus optional JSON-ish metadata), and the core
+ * operation is an approximate-nearest-neighbor similarity `query`, not a
+ * `WHERE`-filtered row scan. There is no SQL, no joins, no transactions, and
+ * metadata filters only ever narrow a similarity search rather than stand
+ * alone as a general query language. None of that fits the SQL-shaped
+ * `Dialect` interface (`src/dialects/dialect.ts`), so this class instead
+ * implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes Pinecone's real operations (index
+ * admin, upsert/query/fetch/update/delete, namespaces) directly.
+ *
+ * Uses the official `@pinecone-database/pinecone` driver. Unlike Redis or
+ * MongoDB, Pinecone's client is a stateless HTTPS client - there is no
+ * socket handshake to perform up front, so `connect()`/`disconnect()` here
+ * construct/discard the client object rather than opening a real
+ * connection; connectivity is only proven the first time a request is
+ * actually made.
+ */
+import { Pinecone, type PineconeConfiguration, type IndexModel, type IndexList, type CreateIndexOptions as PineconeCreateIndexOptions, type PineconeRecord, type RecordMetadata, type QueryOptions as PineconeQueryOptions, type QueryResponse, type FetchResponse, type IndexStatsDescription, Errors as PineconeErrors } from '@pinecone-database/pinecone';
+import type { NoSqlStore } from '../store';
+/**
+ * Connection options for `PineconeStore`. Mirrors the real client's
+ * `PineconeConfiguration` (`apiKey` plus a handful of optional transport
+ * settings) - all fields are passed straight through to `new Pinecone(...)`.
+ */
+export type PineconeStoreOptions = PineconeConfiguration;
+/** How an index should be deployed - re-exported so callers don't need a direct dependency on the driver's types. */
+export type CreateIndexOptions = PineconeCreateIndexOptions;
+/** A vector record: an id, its embedding values, and optional metadata. */
+export type VectorRecord<T extends RecordMetadata = RecordMetadata> = PineconeRecord<T>;
+/** Options accepted by `upsert()`. */
+export interface UpsertVectorsOptions {
+    /** Namespace to upsert into. Defaults to the default namespace (`''`) when omitted. */
+    namespace?: string;
+}
+/** Options accepted by `query()`, matching the real SDK's query-by-vector or query-by-id union. */
+export type QueryVectorsOptions = PineconeQueryOptions;
+/** Options accepted by `fetch()`. */
+export interface FetchVectorsOptions {
+    namespace?: string;
+}
+/** Options accepted by `deleteByIds()`. */
+export interface DeleteByIdsOptions {
+    namespace?: string;
+}
+/** Options accepted by `deleteByFilter()`. */
+export interface DeleteByFilterOptions {
+    namespace?: string;
+}
+/** Options accepted by `deleteAll()`. */
+export interface DeleteAllVectorsOptions {
+    namespace?: string;
+}
+/** Options accepted by `update()`. Either `values` or `metadata` (or both) may be provided. */
+export interface UpdateVectorOptions<T extends RecordMetadata = RecordMetadata> {
+    id: string;
+    values?: number[];
+    metadata?: Partial<T>;
+    namespace?: string;
+}
+/** Options accepted by `describeIndexStats()`. */
+export interface DescribeIndexStatsOptions {
+    /** Only return statistics for vectors that satisfy this metadata filter. */
+    filter?: object;
+}
+/**
+ * `PineconeStore` wraps the `@pinecone-database/pinecone` client and
+ * exposes index administration plus the vector data-plane operations
+ * (upsert/query/fetch/update/delete) as a typed, promise-based API.
+ *
+ * Every data-plane method (`upsert`, `query`, `fetch`, `update`,
+ * `deleteByIds`, `deleteByFilter`, `deleteAll`, `describeIndexStats`)
+ * targets a specific index by name and accepts an optional `namespace` to
+ * scope the operation, mirroring the real SDK's `index.namespace(ns)`
+ * pattern - Pinecone partitions the vectors within a single index into
+ * namespaces, and most operations are namespace-scoped rather than
+ * index-wide.
+ */
+export declare class PineconeStore implements NoSqlStore {
+    readonly name = "pinecone";
+    readonly library = "@pinecone-database/pinecone";
+    private readonly options;
+    private client;
+    private connected;
+    /** One `Index` handle per (indexName, namespace) pair, reused across calls. */
+    private readonly indexCache;
+    constructor(options: PineconeStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `Pinecone` client for anything not wrapped here (e.g. collections, assistants, inference). */
+    getClient(): Pinecone;
+    private requireClient;
+    /** Resolve (and cache) an `Index` handle targeting `indexName`, optionally scoped to `namespace`. */
+    private resolveIndex;
+    private exec;
+    /** List all indexes in the project. */
+    listIndexes(): Promise<IndexList>;
+    /** Describe a single index (dimension, metric, host, spec, ready status). */
+    describeIndex(indexName: string): Promise<IndexModel>;
+    /**
+     * Create a new index. `options.spec` selects the deployment shape -
+     * `{ serverless: { cloud, region } }` for a serverless index or
+     * `{ pod: { environment, podType, ... } }` for a pod-based index - and is
+     * required by the underlying SDK, matching Pinecone's actual index
+     * lifecycle (there is no dimension-less/spec-less index).
+     */
+    createIndex(options: CreateIndexOptions): Promise<IndexModel | void>;
+    /** Delete an index by name. Irreversible - all vectors in every namespace are destroyed with it. */
+    deleteIndex(indexName: string): Promise<void>;
+    /**
+     * Upsert one or more vector records into `indexName`. If a record's `id`
+     * already exists, its `values`/`metadata` are overwritten in full (not
+     * merged) - this is the same "insert or fully replace" semantics as the
+     * real Pinecone `upsert` API.
+     */
+    upsert<T extends RecordMetadata = RecordMetadata>(indexName: string, records: VectorRecord<T> | Array<VectorRecord<T>>, options?: UpsertVectorsOptions): Promise<void>;
+    /**
+     * Find the `topK` records most similar to a query vector (`options.vector`)
+     * or to an existing record's vector (`options.id`). See
+     * {@link QueryVectorsOptions}/the real SDK's `QueryOptions` for
+     * `filter`/`includeMetadata`/`includeValues`.
+     */
+    query<T extends RecordMetadata = RecordMetadata>(indexName: string, options: QueryVectorsOptions, namespace?: string): Promise<QueryResponse<T>>;
+    /** Fetch one or more records by id. Ids that don't exist are simply absent from `records` in the response. */
+    fetch<T extends RecordMetadata = RecordMetadata>(indexName: string, ids: string[], options?: FetchVectorsOptions): Promise<FetchResponse<T>>;
+    /**
+     * Update an existing record by id. A provided `values` array overwrites
+     * the stored vector; a provided `metadata` object is merged into the
+     * existing metadata (only the given fields are added/changed, matching
+     * the real SDK's partial-update semantics).
+     */
+    update<T extends RecordMetadata = RecordMetadata>(indexName: string, options: UpdateVectorOptions<T>): Promise<void>;
+    /** Delete records by id. */
+    deleteByIds(indexName: string, ids: string[], options?: DeleteByIdsOptions): Promise<void>;
+    /** Delete every record matching a metadata filter (e.g. `{ genre: { $eq: 'classical' } }`). */
+    deleteByFilter(indexName: string, filter: object, options?: DeleteByFilterOptions): Promise<void>;
+    /** Delete every record in a namespace (or the default namespace, if none is given). */
+    deleteAll(indexName: string, options?: DeleteAllVectorsOptions): Promise<void>;
+    /** Record counts per namespace, the index's configured dimension, and (for pod-based indexes) fullness. */
+    describeIndexStats(indexName: string, options?: DescribeIndexStatsOptions): Promise<IndexStatsDescription>;
+}
+/** Re-export of the driver's error namespace, for callers that want to `instanceof`-check a caught `DatabaseError.parent`. */
+export { PineconeErrors };
+export default PineconeStore;

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

@@ -0,0 +1,90 @@
+/**
+ * Apache Pinot store.
+ *
+ * Pinot is a real-time distributed OLAP datastore built for low-latency
+ * analytics on both streaming and batch data. Queries are issued against a
+ * *broker* over an HTTP/JSON API using Pinot SQL; results come back in a
+ * columnar `resultTable` envelope (a `dataSchema` plus positional `rows`).
+ * Pinot has no client-side row `INSERT` path (real-time ingestion is driven
+ * by Kafka/stream connectors configured server-side), so it does not fit the
+ * SQL-shaped `Dialect` interface (`src/dialects/dialect.ts`). This class
+ * implements the minimal `NoSqlStore` marker interface (`src/nosql/store.ts`)
+ * and exposes Pinot's read-only broker query API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Pinot has no single canonical npm client; the broker is just an HTTP/JSON
+ * API. This store uses the global `fetch`. Tests (and callers wanting their
+ * own transport) inject an alternative client via `PinotStoreOptions.client`;
+ * when omitted a tiny `fetch`-based client is built against `endpoint` on
+ * `connect()`.
+ */
+import { NoSqlStore } from '../store';
+/** Default Pinot broker HTTP endpoint. */
+export declare const DEFAULT_PINOT_ENDPOINT = "http://localhost:8000";
+/**
+ * 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 PinotHttpClient {
+    /** Issue a POST with a JSON body and return the parsed JSON response. */
+    post(path: string, body: unknown): Promise<any>;
+}
+/** Connection options for `PinotStore`. */
+export interface PinotStoreOptions {
+    /** Base HTTP endpoint of the Pinot broker. Defaults to `http://localhost:8000`. */
+    endpoint?: string;
+    /**
+     * Optional pre-built HTTP client. When provided it is used verbatim and
+     * `endpoint` is ignored; otherwise an internal `fetch`-based client is built
+     * against `endpoint` on `connect()`. Tests inject a mock here.
+     */
+    client?: PinotHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Pinot's columnar result envelope. */
+export interface PinotResultTable {
+    dataSchema?: {
+        columnNames?: string[];
+        columnDataTypes?: string[];
+    };
+    rows?: unknown[][];
+}
+/** Build a `fetch`-backed client for the given endpoint. */
+export declare function createFetchClient(endpoint: string, headers?: Record<string, string>): PinotHttpClient;
+/**
+ * `PinotStore` wraps Pinot's broker query API (`POST /query/sql`) behind the
+ * `NoSqlStore` lifecycle. `query()` maps the columnar `resultTable` into an
+ * array of row objects; `queryTable()` returns the raw `resultTable` envelope
+ * for callers who need the schema or the positional rows.
+ */
+export declare class PinotStore implements NoSqlStore {
+    readonly name = "pinot";
+    readonly library = "fetch";
+    private readonly endpoint;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: PinotStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): PinotHttpClient;
+    private requireClient;
+    private runSql;
+    /**
+     * Run a Pinot SQL query via `POST /query/sql` and return the rows as an
+     * array of objects keyed by the result column names. For the raw columnar
+     * envelope (schema + positional rows), use `queryTable()`.
+     */
+    query<T = Record<string, unknown>>(sql: string): Promise<T[]>;
+    /**
+     * Run a Pinot SQL query and return the raw `resultTable` envelope
+     * (`dataSchema` + positional `rows`), exactly as the broker returns it.
+     */
+    queryTable(sql: string): Promise<PinotResultTable>;
+}
+export default PinotStore;

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

@@ -0,0 +1,95 @@
+import type { NoSqlStore } from '../store';
+/** A PouchDB document: an arbitrary record that carries an `_id` (and, once stored, a `_rev`). */
+export type PouchDoc = Record<string, unknown> & {
+    _id?: string;
+    _rev?: string;
+};
+/** A single entry in a `batch()` write: a `put` (with document value) or a `del`. */
+export type PouchBatchOp = {
+    type: 'put';
+    key: string;
+    value: Record<string, unknown>;
+} | {
+    type: 'del';
+    key: string;
+};
+/** Result of a mutating call (`put`/`remove`): the affected id/rev and an `ok` flag. */
+export interface PouchWriteResult {
+    ok: boolean;
+    id: string;
+    rev: string;
+}
+/**
+ * Minimal structural type for the pieces of a `pouchdb` database this store
+ * uses. Kept local (rather than importing from `pouchdb`) so this module
+ * type-checks without the optional driver installed.
+ */
+export interface PouchClientLike {
+    put(doc: PouchDoc): Promise<PouchWriteResult>;
+    get(id: string): Promise<PouchDoc>;
+    remove(doc: PouchDoc): Promise<PouchWriteResult>;
+    bulkDocs(docs: PouchDoc[]): Promise<PouchWriteResult[]>;
+    allDocs(options?: Record<string, unknown>): Promise<{
+        rows: {
+            id: string;
+            key: string;
+        }[];
+    }>;
+    close(): Promise<void>;
+}
+/** Connection options for `PouchdbStore`. */
+export interface PouchdbStoreOptions {
+    /** Database name / path passed to `new PouchDB(name)`. Defaults to `'./data/pouchdb'`. */
+    name?: string;
+    /**
+     * Escape hatch for any other `PouchDB` constructor option (adapter, auth,
+     * ...). Passed as the second argument to `new PouchDB(name, config)`.
+     */
+    config?: Record<string, unknown>;
+    /**
+     * A pre-built `pouchdb` database (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('pouchdb')` entirely —
+     * this is how tests inject a mock without the real driver installed.
+     */
+    client?: PouchClientLike;
+}
+/**
+ * `PouchdbStore` wraps a `pouchdb` database and exposes both a common KV
+ * surface — `put`/`get`/`del` keyed on `_id`, `batch`, `list` — and PouchDB's
+ * native `insert`/`allDocs` operations.
+ */
+export declare class PouchdbStore implements NoSqlStore {
+    readonly name = "pouchdb";
+    readonly library = "pouchdb";
+    private readonly options;
+    private readonly dbName;
+    private client;
+    private connected;
+    constructor(options?: PouchdbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `pouchdb` database for anything not wrapped here. */
+    getClient(): PouchClientLike;
+    private requireClient;
+    private wrapError;
+    /** Writes a document keyed by `_id = key` (PouchDB `put`), merging `key` in as its `_id`. */
+    put(key: string, value: Record<string, unknown>): Promise<PouchWriteResult>;
+    /** Native `insert`: stores a document as-is (must carry its own `_id`). */
+    insert(doc: PouchDoc): Promise<PouchWriteResult>;
+    /** Reads a document by `_id` (PouchDB `get`). */
+    get(key: string): Promise<PouchDoc>;
+    /**
+     * Deletes a document by `_id`. PouchDB needs the current `_rev` to delete, so
+     * this first `get`s the document, then `remove`s it.
+     */
+    del(key: string): Promise<PouchWriteResult>;
+    /** Applies a list of `put`/`del` operations. Puts go through `bulkDocs`; deletes are resolved individually. */
+    batch(ops: PouchBatchOp[]): Promise<void>;
+    /**
+     * Lists document ids via `allDocs`. With `prefix`, restricts to ids
+     * `>= prefix` and `<= prefix + '￿'` (PouchDB's startkey/endkey range).
+     */
+    list(prefix?: string): Promise<string[]>;
+}
+export default PouchdbStore;

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

@@ -0,0 +1,112 @@
+/**
+ * Prometheus store implementation.
+ *
+ * Prometheus is a pull-based time-series monitoring system. It is queried
+ * over its HTTP API using PromQL (Prometheus Query Language). There is no
+ * SQL-shaped query surface, no row-level UPDATE/DELETE, and no client-side
+ * ingestion path (Prometheus scrapes targets itself), so it 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 Prometheus's read-only HTTP query API directly.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Prometheus has no single canonical npm client library; it is just an
+ * HTTP/JSON API. Rather than depend on any package, this store talks to
+ * the server with the global `fetch`. For tests (and for callers who want
+ * to route requests through their own transport), an alternative HTTP
+ * client can be injected via `PrometheusStoreOptions.client`; when omitted,
+ * a tiny internal client over `fetch` + `baseURL` is built at connect time.
+ *
+ * ## Endpoints wrapped (all read-only, all under `/api/v1`)
+ *
+ * - `instantQuery(promql, time?)`      -> `GET /api/v1/query`
+ * - `rangeQuery(promql, {start,end,step})` -> `GET /api/v1/query_range`
+ * - `series(match)`                    -> `GET /api/v1/series`
+ * - `labelValues(label)`               -> `GET /api/v1/label/<label>/values`
+ *
+ * Each method returns the parsed `data` field of the Prometheus response
+ * envelope (`{ status: 'success', data: ... }`).
+ */
+import { NoSqlStore } from '../store';
+/** Default Prometheus HTTP API base URL. */
+export declare const DEFAULT_PROMETHEUS_BASE_URL = "http://localhost:9090";
+/** 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 PrometheusHttpClient {
+    /** 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/text response (optional). */
+    post?(path: string, body: string, contentType?: string): Promise<any>;
+}
+/** Connection options for `PrometheusStore`. */
+export interface PrometheusStoreOptions {
+    /** Base URL of the Prometheus server. Defaults to `http://localhost:9090`. */
+    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?: PrometheusHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Time bounds + resolution for a PromQL range query. */
+export interface RangeQueryOptions {
+    /** Start timestamp (RFC3339 or Unix seconds). */
+    start: string | number;
+    /** End timestamp (RFC3339 or Unix seconds). */
+    end: string | number;
+    /** Query resolution step (duration string like `15s` or seconds). */
+    step: string | number;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): PrometheusHttpClient;
+/**
+ * `PrometheusStore` wraps Prometheus's read-only HTTP query API (PromQL
+ * instant/range queries plus series/label metadata lookups) behind the
+ * `NoSqlStore` lifecycle. It performs no writes - Prometheus ingests data
+ * by scraping targets, not by client-side pushes.
+ */
+export declare class PrometheusStore implements NoSqlStore {
+    readonly name = "prometheus";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: PrometheusStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): PrometheusHttpClient;
+    private requireClient;
+    private get;
+    /**
+     * Runs a PromQL instant query at a single point in time via
+     * `GET /api/v1/query`. Returns the `data` payload (result type + result).
+     */
+    instantQuery(promql: string, time?: string | number): Promise<any>;
+    /**
+     * Runs a PromQL range query over `[start, end]` at `step` resolution via
+     * `GET /api/v1/query_range`. Returns the `data` payload (matrix result).
+     */
+    rangeQuery(promql: string, options: RangeQueryOptions): Promise<any>;
+    /**
+     * Finds series matching one or more PromQL series selectors via
+     * `GET /api/v1/series`. Returns the array of matching label sets.
+     */
+    series(match: string | string[]): Promise<any>;
+    /**
+     * Lists the distinct values of a label via
+     * `GET /api/v1/label/<label>/values`. Returns the array of values.
+     */
+    labelValues(label: string): Promise<any>;
+}