ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,117 @@
+import type { NoSqlStore } from '../store';
+/**
+ * A single statement for `batch()`: a CQL string plus its bound parameters.
+ * Mirrors the `cassandra-driver` batch query shape.
+ */
+export interface ScyllaBatchQuery {
+    query: string;
+    params?: unknown[];
+}
+/**
+ * Options for `execute()` / `batch()`. Forwarded straight through to the
+ * driver's query-options bag (consistency, fetchSize, pageState, timestamp,
+ * etc.). `prepare` defaults to `true` here (see `execute()`), overridable per
+ * call.
+ */
+export interface ScyllaQueryOptions {
+    prepare?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * The shape of a `cassandra-driver` result. Only `rows` is relied on here; the
+ * rest of the driver's result metadata is preserved via the index signature.
+ */
+export interface ScyllaResult<T = Record<string, unknown>> {
+    rows?: T[];
+    [key: string]: unknown;
+}
+/**
+ * Minimal structural type for the pieces of a `cassandra-driver` `Client` this
+ * store uses. Kept local so this module type-checks without the optional
+ * driver installed.
+ */
+export interface ScyllaClientLike {
+    connect(): Promise<void>;
+    execute(query: string, params?: unknown[], options?: Record<string, unknown>): Promise<ScyllaResult>;
+    batch(queries: ScyllaBatchQuery[], options?: Record<string, unknown>): Promise<ScyllaResult>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Connection options for `ScyllaStore`. These map onto the `cassandra-driver`
+ * `Client` constructor options.
+ */
+export interface ScyllaStoreOptions {
+    /** Seed node addresses, e.g. `['127.0.0.1']` or `['10.0.0.1:9042']`. */
+    contactPoints?: string[];
+    /** Local data center name (required by the driver's default load-balancing policy). */
+    localDataCenter?: string;
+    /** Default keyspace to bind the session to. */
+    keyspace?: string;
+    /** Plain-text auth credentials passed to the driver. */
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    /**
+     * Escape hatch for any other `cassandra-driver` `Client` option (pooling,
+     * SSL, policies, socketOptions, ...). Merged into the options passed to the
+     * `Client` constructor.
+     */
+    clientOptions?: Record<string, unknown>;
+    /**
+     * A pre-built driver `Client` (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('cassandra-driver')`
+     * entirely — this is how tests inject a mock without the real driver
+     * installed.
+     */
+    client?: ScyllaClientLike;
+}
+/**
+ * `ScyllaStore` wraps a `cassandra-driver` `Client` and exposes CQL execution
+ * (`execute`), atomic multi-statement batches (`batch`), and a few
+ * parameterized convenience helpers (`insert`, `selectAll`).
+ *
+ * Statements are prepared by default (`prepare: true`) so the driver can cache
+ * query metadata, infer parameter types, and route requests to the shard/replica
+ * that owns the partition — the recommended default for anything run more than
+ * once, and especially valuable on ScyllaDB's shard-aware driver path.
+ */
+export declare class ScyllaStore implements NoSqlStore {
+    readonly name = "scylladb";
+    readonly library = "cassandra-driver";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: ScyllaStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `cassandra-driver` `Client` for anything not wrapped here. */
+    getClient(): ScyllaClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Execute a single CQL statement with optional bound `params`. Statements
+     * are prepared by default (`prepare: true`); pass `opts.prepare = false` to
+     * run a one-off unprepared. Any other driver query options are forwarded via
+     * `opts`. Returns the full driver result (with `.rows`).
+     */
+    execute<T = Record<string, unknown>>(query: string, params?: unknown[], opts?: ScyllaQueryOptions): Promise<ScyllaResult<T>>;
+    /**
+     * Execute multiple statements as a single logged batch (atomic across the
+     * statements, though not isolated — CQL batches are not SQL transactions).
+     * Each entry is a `{ query, params }` pair. Prepared by default; forward
+     * other driver batch options via `opts`.
+     */
+    batch(queries: ScyllaBatchQuery[], opts?: ScyllaQueryOptions): Promise<ScyllaResult>;
+    /**
+     * Convenience `INSERT`: builds a parameterized
+     * `INSERT INTO table (cols...) VALUES (?, ?, ...)` from `obj`'s keys and
+     * executes it (prepared). For upserts with TTL, IF NOT EXISTS, or other
+     * clauses, write the CQL yourself and call `execute()`.
+     */
+    insert(table: string, obj: Record<string, unknown>, opts?: ScyllaQueryOptions): Promise<ScyllaResult>;
+    /** Convenience `SELECT * FROM table`. Returns the full driver result (with `.rows`). */
+    selectAll<T = Record<string, unknown>>(table: string, opts?: ScyllaQueryOptions): Promise<ScyllaResult<T>>;
+}
+export default ScyllaStore;

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

@@ -0,0 +1,116 @@
+/**
+ * SigNoz store implementation.
+ *
+ * SigNoz is an open-source, ClickHouse-backed observability platform for
+ * logs, traces, and metrics. Logs are ingested over OTLP/HTTP (the
+ * OpenTelemetry logs protocol) and queried through SigNoz's query-range API
+ * (a builder-style JSON body over its ClickHouse store). There is no
+ * SQL-shaped query surface exposed to clients, no row-level UPDATE/DELETE,
+ * and no identifier escaping, so SigNoz 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 SigNoz's
+ * OTLP ingest + query API.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * SigNoz has no single canonical npm client; ingest is OTLP/HTTP JSON and
+ * query is a REST/JSON API. This store talks to both with the global `fetch`
+ * (so `library` is `'fetch'`). For tests (and custom transports) an
+ * alternative HTTP client can be injected via `SigNozStoreOptions.client`.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(resource, entries)` -> `POST /v1/logs`          (OTLP/HTTP ingest)
+ * - `query(builder, opts?)`   -> `POST /api/v4/query_range` (query-range)
+ * - `labels()`                -> `GET  /api/v1/logs/fields`  (log field keys)
+ * - `streams()`               -> `GET  /api/v1/services`     (services)
+ */
+import { NoSqlStore } from '../store';
+/** Default SigNoz base URL (query service). */
+export declare const DEFAULT_SIGNOZ_BASE_URL = "http://localhost:8080";
+/** 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 SigNozHttpClient {
+    /** 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 `SigNozStore`. */
+export interface SigNozStoreOptions {
+    /** Base URL of the SigNoz query service. Defaults to `http://localhost:8080`. */
+    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?: SigNozHttpClient;
+    /** Extra HTTP headers (e.g. `SIGNOZ-API-KEY`) sent with every request. */
+    headers?: Record<string, string>;
+}
+/** A log record to ingest, in a simplified shape mapped onto OTLP. */
+export interface SigNozLogEntry {
+    /** Unix-nanosecond timestamp. */
+    timeUnixNano?: string | number;
+    /** Severity text (e.g. `INFO`, `ERROR`). */
+    severity?: string;
+    /** The log body/message. */
+    body: string;
+    /** Structured attributes for this record. */
+    attributes?: Record<string, string | number | boolean>;
+}
+/** Options for a query-range request. */
+export interface SigNozQueryOptions {
+    /** Start of the query window (epoch ms). */
+    start?: number;
+    /** End of the query window (epoch ms). */
+    end?: number;
+    /** Aggregation step in seconds. */
+    step?: number;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): SigNozHttpClient;
+/**
+ * `SigNozStore` wraps SigNoz's OTLP/HTTP log ingest and its query-range API
+ * (plus log-field and service metadata) behind the `NoSqlStore` lifecycle.
+ */
+export declare class SigNozStore implements NoSqlStore {
+    readonly name = "signoz";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: SigNozStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): SigNozHttpClient;
+    private requireClient;
+    private doGet;
+    /**
+     * Ingests log records over OTLP/HTTP via `POST /v1/logs`. The simplified
+     * `entries` are assembled into the OTLP `resourceLogs -> scopeLogs ->
+     * logRecords` envelope, tagged with the shared `resource` attributes.
+     */
+    push(resource: Record<string, string | number | boolean>, entries: SigNozLogEntry[]): Promise<any>;
+    /**
+     * Runs a query-range request via `POST /api/v4/query_range`. The
+     * `builder` is SigNoz's composite query payload (`compositeQuery` /
+     * builder queries); `start`/`end`/`step` fill the time window. Returns the
+     * parsed response.
+     */
+    query(builder: Record<string, unknown>, options?: SigNozQueryOptions): Promise<any>;
+    /** Lists the known log field/attribute keys via `GET /api/v1/logs/fields`. */
+    labels(): Promise<any>;
+    /** Lists the observed services via `GET /api/v1/services`. */
+    streams(): Promise<any>;
+}
+export default SigNozStore;

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

@@ -0,0 +1,99 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`: raw string/Buffer or a JSON-serializable value. */
+export type SnsMessage = string | Buffer | Record<string, unknown> | unknown[];
+/**
+ * A loosely-typed handle to an AWS v3 `SNSClient` (or any object exposing a
+ * compatible `send(command)` method). Tests inject a mock matching this shape.
+ */
+export interface SnsClientLike {
+    send(command: unknown): Promise<any>;
+    destroy?(): void;
+}
+/** Connection options for `SnsStore`. */
+export interface SnsStoreOptions {
+    /** AWS region, e.g. 'us-east-1'. */
+    region?: string;
+    /** Static credentials. Omit to use the default AWS credential provider chain. */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Override the service endpoint (e.g. 'http://localhost:4566' for LocalStack). */
+    endpoint?: string;
+    /**
+     * A pre-built `SNSClient` (or compatible object). When provided, `connect()`
+     * uses it directly and does NOT require the SDK — this is how tests inject a
+     * mock client.
+     */
+    client?: SnsClientLike;
+}
+/** Options for `publish()` (`Publish`). */
+export interface SnsPublishOptions {
+    /** Subject line (for email endpoints). */
+    subject?: string;
+    /** FIFO group id (required for FIFO topics). */
+    messageGroupId?: string;
+    /** FIFO dedupe id. */
+    messageDeduplicationId?: string;
+    /** Message attributes, passed straight through. */
+    messageAttributes?: Record<string, unknown>;
+    /** Set true when `message` is a JSON structure with per-protocol overrides. */
+    messageStructureJson?: boolean;
+}
+/** Result of `publish()`. */
+export interface SnsPublishResult {
+    messageId?: string;
+    sequenceNumber?: string;
+}
+/** Options for `subscribe()` (`Subscribe`). */
+export interface SnsSubscribeOptions {
+    /**
+     * Delivery protocol: 'sqs', 'lambda', 'https', 'http', 'email',
+     * 'email-json', 'sms', or 'application'. Defaults to 'https'.
+     */
+    protocol?: string;
+    /** Return the subscription ARN immediately without waiting for confirmation. */
+    returnSubscriptionArn?: boolean;
+    /** Subscription attributes (e.g. `FilterPolicy`, `RawMessageDelivery`). */
+    attributes?: Record<string, string>;
+}
+/**
+ * `SnsStore` wraps an AWS v3 `SNSClient` and exposes topic publishing,
+ * endpoint subscription registration, and topic administration.
+ */
+export declare class SnsStore implements NoSqlStore {
+    readonly name = "sns";
+    readonly library = "@aws-sdk/client-sns";
+    private readonly options;
+    private client;
+    private aws;
+    private connected;
+    constructor(options?: SnsStoreOptions);
+    connect(): Promise<void>;
+    private tryLoadSdk;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `SNSClient` (loosely typed) for anything not wrapped here. */
+    getClient(): SnsClientLike;
+    private requireClient;
+    private command;
+    private wrapError;
+    /**
+     * `Publish` — publish one `message` to the topic at `topicArn`. The message
+     * is encoded to a string (string as-is, Buffer → UTF-8, else JSON). Returns
+     * the message id (and FIFO sequence number, if any).
+     */
+    publish(topicArn: string, message: SnsMessage, options?: SnsPublishOptions): Promise<SnsPublishResult>;
+    /** `CreateTopic` — create a topic by name. Returns its ARN. */
+    createTopic(name: string, attributes?: Record<string, string>): Promise<string | undefined>;
+    /**
+     * `Subscribe` — register a push `endpoint` on the topic at `topicArn`. Unlike
+     * poll-based engines, SNS pushes notifications to the endpoint, so this takes
+     * an endpoint (SQS/Lambda ARN, HTTPS URL, email, ...) and a protocol rather
+     * than a message handler. Returns the subscription ARN (or 'pending
+     * confirmation' for endpoints that require confirmation).
+     */
+    subscribe(topicArn: string, endpoint: string, options?: SnsSubscribeOptions): Promise<string | undefined>;
+}
+export default SnsStore;

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

@@ -0,0 +1,129 @@
+/**
+ * Apache Solr store implementation.
+ *
+ * Solr is a search engine built on Lucene: documents are schema-flexible
+ * JSON records indexed into a "core" (or "collection" in SolrCloud), and
+ * the primary operation is a Lucene/DisMax query (`q`, `fq`, `fl`, `sort`,
+ * `start`/`rows`, faceting) against that inverted index - not SQL, not
+ * joins, not a transaction log. Writes are buffered until an explicit
+ * `commit` makes them searchable. None of that fits the SQL-shaped
+ * `Dialect` interface used by the SQL dialects in this repo, so this class
+ * implements the minimal `NoSqlStore` marker interface (`src/nosql/store.ts`)
+ * and exposes Solr's real operations (add, search, delete, commit, optimize)
+ * directly.
+ *
+ * Uses the `solr-client` driver, lazy-loaded inside `connect()` via
+ * `require()` so the dependency is only needed when a Solr store is actually
+ * constructed (tests inject a pre-built mock `client` instead).
+ *
+ * ## Driver call shape (callback vs promise)
+ *
+ * The classic `solr-client` API is Node-style callbacks:
+ * `client.add(docs, (err, obj) => ...)`, `client.commit(cb)`,
+ * `client.search(query, cb)`, `client.deleteByID(id, cb)`,
+ * `client.deleteByQuery(q, cb)`, `client.optimize(cb)`. Some builds /
+ * forks instead return a Promise when no callback is passed. To work with
+ * either, every call goes through {@link invoke}, which passes a callback
+ * *and* inspects the return value: if the driver returned a thenable it is
+ * awaited directly (the callback is then ignored), otherwise the callback
+ * settles the Promise. `client.query()` (when present) builds a query
+ * object via a fluent builder; if the driver doesn't expose it, `search()`
+ * accepts a raw query object/string unchanged.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `SolrStore`. Mirror the fields `solr-client`'s
+ * `createClient()` accepts; the whole object is forwarded to
+ * `solr.createClient(...)`, so any additional driver options (`path`,
+ * `protocol`, `secure`, `bigint`, etc.) pass straight through.
+ */
+export interface SolrStoreOptions {
+    /** Solr host. Defaults to the driver's own default (`127.0.0.1`). */
+    host?: string;
+    /** Solr port. Defaults to the driver's own default (`8983`). */
+    port?: number | string;
+    /** The core (or SolrCloud collection) to target. */
+    core?: string;
+    /** Base path Solr is mounted under. Defaults to the driver's default (`/solr`). */
+    path?: string;
+    /** `http` or `https`. */
+    protocol?: string;
+    /** Use HTTPS. */
+    secure?: boolean;
+    /**
+     * A pre-built `solr-client` client. When provided, `connect()` skips the
+     * `require('solr-client')` / `createClient()` step and uses this instead -
+     * the injection point used by tests to supply a mock.
+     */
+    client?: SolrClientLike;
+    /** Any other option accepted by `solr.createClient(...)`. */
+    [key: string]: unknown;
+}
+/** The subset of the `solr-client` client surface this store uses. */
+export interface SolrClientLike {
+    add(docs: unknown, callback?: SolrCallback): unknown;
+    commit(callback?: SolrCallback): unknown;
+    optimize?(options?: unknown, callback?: SolrCallback): unknown;
+    search(query: unknown, callback?: SolrCallback): unknown;
+    deleteByID(id: string | number, callback?: SolrCallback): unknown;
+    deleteByQuery(query: string, callback?: SolrCallback): unknown;
+    /** Fluent query builder (`client.query().q(...).start(...)...`), when the driver exposes it. */
+    query?(): unknown;
+    [key: string]: unknown;
+}
+type SolrCallback = (err: unknown, result?: unknown) => void;
+/**
+ * `SolrStore` wraps a `solr-client` client and exposes Solr's document
+ * indexing, querying, deletion, and commit/optimize operations as a typed,
+ * promise-based API.
+ */
+export declare class SolrStore implements NoSqlStore {
+    readonly name = "solr";
+    readonly library = "solr-client";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: SolrStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `solr-client` client for anything not wrapped here. */
+    getClient(): SolrClientLike;
+    private requireClient;
+    private exec;
+    /**
+     * Add (index) one or more documents, then `commit` so they become
+     * searchable. Solr buffers adds until a commit, so the two are done
+     * together here for the common "index and see it" case; call `add` via
+     * `getClient()` directly if you want to batch many adds before a single
+     * commit.
+     */
+    add(docs: Record<string, unknown> | Array<Record<string, unknown>>): Promise<unknown>;
+    /**
+     * Run a query. Pass either a raw query object/string (Solr query params,
+     * e.g. `'q=title:solr&rows=10'`) or a query built by
+     * {@link SolrStore.query}. Returns the driver's raw response object
+     * (`{ responseHeader, response: { numFound, docs, ... } }`).
+     */
+    search(query: unknown): Promise<unknown>;
+    /**
+     * Build a query with the driver's fluent builder (`.q(...)`, `.start(...)`,
+     * `.rows(...)`, `.sort(...)`, ...), when the driver exposes `client.query()`.
+     * Throws if this driver build doesn't provide a builder - construct a raw
+     * query object/string and pass it straight to {@link SolrStore.search} in
+     * that case.
+     */
+    query(): unknown;
+    /** Delete a single document by its unique-key value, then commit. */
+    deleteByID(id: string | number): Promise<unknown>;
+    /** Delete every document matching a Solr query (e.g. `'category:obsolete'`), then commit. */
+    deleteByQuery(query: string): Promise<unknown>;
+    /** Commit buffered writes so they become visible to search. */
+    commit(): Promise<unknown>;
+    /**
+     * Optimize the index (merge segments). Optional - not every `solr-client`
+     * build exposes `optimize`; throws a `DatabaseError` if this one doesn't.
+     */
+    optimize(): Promise<unknown>;
+}
+export default SolrStore;

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

@@ -0,0 +1,125 @@
+/**
+ * Splunk store implementation.
+ *
+ * Splunk is a log-ingestion and search platform. Data is ingested through
+ * the HTTP Event Collector (HEC) and searched with SPL (Search Processing
+ * Language) via the REST search API. There is no SQL-shaped query surface,
+ * no row-level UPDATE/DELETE, and no identifier escaping, so Splunk 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 Splunk's ingest/search API.
+ *
+ * ## Driver: `splunk-sdk` if present, else HTTP over `fetch`
+ *
+ * If the optional `splunk-sdk` package is installed it is lazily required at
+ * connect time and exposed via `getSdk()`; the ingest/search methods here
+ * always speak the REST/HEC HTTP API over the global `fetch` (so `library`
+ * is `'fetch'`). For tests (and custom transports) an alternative HTTP
+ * client can be injected via `SplunkStoreOptions.client`.
+ *
+ * ## Endpoints wrapped
+ *
+ * - `push(meta, events)` -> `POST /services/collector/event`  (HEC ingest)
+ * - `query(spl, opts?)`  -> `POST /services/search/jobs`       (SPL search)
+ * - `labels()`           -> `GET  /services/data/sourcetypes`  (sourcetypes)
+ * - `streams()`          -> `GET  /services/data/indexes`      (indexes)
+ */
+import { NoSqlStore } from '../store';
+/** Default Splunk management/REST base URL. */
+export declare const DEFAULT_SPLUNK_BASE_URL = "https://localhost:8088";
+/** 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 SplunkHttpClient {
+    /** 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 `SplunkStore`. */
+export interface SplunkStoreOptions {
+    /** Base URL of the Splunk HEC/REST endpoint. Defaults to `https://localhost:8088`. */
+    baseURL?: string;
+    /** HEC token used for ingest (`Authorization: Splunk <token>`). */
+    token?: 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?: SplunkHttpClient;
+    /** Extra HTTP headers sent with every internal-client request. */
+    headers?: Record<string, string>;
+}
+/** Envelope metadata attached to each HEC event. */
+export interface SplunkEventMeta {
+    /** Target index. */
+    index?: string;
+    /** Source type (e.g. `access_combined`). */
+    sourcetype?: string;
+    /** Event source. */
+    source?: string;
+    /** Reporting host. */
+    host?: string;
+}
+/** Options for an SPL search job. */
+export interface SplunkSearchOptions {
+    /** Earliest time modifier (e.g. `-24h`, epoch). */
+    earliest?: string;
+    /** Latest time modifier (e.g. `now`, epoch). */
+    latest?: string;
+    /** Output mode; defaults to `json`. */
+    outputMode?: string;
+    /** Run the search synchronously (`exec_mode=oneshot`) rather than as a job. */
+    oneshot?: boolean;
+}
+/** Build a `fetch`-backed client for the given base URL. */
+export declare function createFetchClient(baseURL: string, headers?: Record<string, string>): SplunkHttpClient;
+/**
+ * `SplunkStore` wraps Splunk's HTTP Event Collector (ingest) and REST search
+ * API (SPL search jobs + index/sourcetype metadata) behind the `NoSqlStore`
+ * lifecycle.
+ */
+export declare class SplunkStore implements NoSqlStore {
+    readonly name = "splunk";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly token?;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private sdk;
+    private connected;
+    constructor(options?: SplunkStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): SplunkHttpClient;
+    /** Returns the lazily-required `splunk-sdk` module, or `null` if not installed. */
+    getSdk(): any;
+    private requireClient;
+    private doGet;
+    /**
+     * Sends a batch of events to the HTTP Event Collector via
+     * `POST /services/collector/event`. Each event is wrapped in a HEC
+     * envelope carrying the shared `meta` (index/sourcetype/source/host); the
+     * envelopes are newline-concatenated as HEC expects.
+     */
+    push(meta: SplunkEventMeta, events: unknown[]): Promise<any>;
+    /**
+     * Dispatches an SPL search via `POST /services/search/jobs`. The `search`
+     * string is normalized to start with `search ` when it isn't already a
+     * generating command. Returns the parsed response (job SID or, for a
+     * oneshot search, the results).
+     */
+    query(spl: string, options?: SplunkSearchOptions): Promise<any>;
+    /** Lists the configured source types via `GET /services/data/sourcetypes`. */
+    labels(): Promise<any>;
+    /** Lists the configured indexes via `GET /services/data/indexes`. */
+    streams(): Promise<any>;
+}
+export default SplunkStore;