ts-prorm-orm 1.1.0 → 1.2.0

package/dist/nosql/influxdb/flux-compiler.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluxPushdownUnsupported = void 0;
+exports.compileFluxPredicate = compileFluxPredicate;
+exports.compileFluxSort = compileFluxSort;
+/** Thrown when a where clause cannot be fully translated to a Flux predicate. */
+class FluxPushdownUnsupported extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FluxPushdownUnsupported';
+    }
+}
+exports.FluxPushdownUnsupported = FluxPushdownUnsupported;
+function opName(key) {
+    if (typeof key === 'symbol')
+        return key.description ?? '';
+    return key.startsWith('$') ? key.slice(1) : key;
+}
+/** Render a JS value as a Flux literal. */
+function lit(value) {
+    if (value === null || value === undefined)
+        return 'false';
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (value instanceof Date)
+        return value.toISOString();
+    // Strings: escape backslashes and double-quotes for a Flux string literal.
+    return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+/** Reference to a pivoted column: `r["name"]` (bracket form handles any key). */
+function col(field) {
+    return `r["${field.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`;
+}
+/** Convert a SQL LIKE pattern into a Flux regex literal body (no anchors added here). */
+function likeToRegexBody(pattern) {
+    let out = '';
+    for (const ch of pattern) {
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += ch.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    }
+    return out;
+}
+function compileOperator(field, op, operand) {
+    const c = col(field);
+    switch (op) {
+        case 'eq':
+        case 'is':
+            return `${c} == ${lit(operand)}`;
+        case 'ne':
+            return `${c} != ${lit(operand)}`;
+        case 'gt':
+            return `${c} > ${lit(operand)}`;
+        case 'gte':
+            return `${c} >= ${lit(operand)}`;
+        case 'lt':
+            return `${c} < ${lit(operand)}`;
+        case 'lte':
+            return `${c} <= ${lit(operand)}`;
+        case 'in':
+            return `contains(value: ${c}, set: [${operand.map(lit).join(', ')}])`;
+        case 'notIn':
+            return `not contains(value: ${c}, set: [${operand.map(lit).join(', ')}])`;
+        case 'between': {
+            const [a, b] = operand;
+            return `(${c} >= ${lit(a)} and ${c} <= ${lit(b)})`;
+        }
+        case 'notBetween': {
+            const [a, b] = operand;
+            return `not (${c} >= ${lit(a)} and ${c} <= ${lit(b)})`;
+        }
+        case 'like':
+            return `${c} =~ /^${likeToRegexBody(String(operand))}$/`;
+        case 'notLike':
+            return `${c} !~ /^${likeToRegexBody(String(operand))}$/`;
+        case 'iLike':
+            return `${c} =~ /(?i)^${likeToRegexBody(String(operand))}$/`;
+        case 'notILike':
+            return `${c} !~ /(?i)^${likeToRegexBody(String(operand))}$/`;
+        case 'startsWith':
+            return `${c} =~ /^${likeToRegexBody(String(operand))}/`;
+        case 'endsWith':
+            return `${c} =~ /${likeToRegexBody(String(operand))}$/`;
+        case 'substring':
+            return `${c} =~ /${likeToRegexBody(String(operand))}/`;
+        case 'regexp':
+            return `${c} =~ /${String(operand)}/`;
+        case 'notRegexp':
+            return `${c} !~ /${String(operand)}/`;
+        case 'iRegexp':
+            return `${c} =~ /(?i)${String(operand)}/`;
+        default:
+            throw new FluxPushdownUnsupported(`operator ${op}`);
+    }
+}
+function compileField(field, condition) {
+    if (condition === null ||
+        typeof condition !== 'object' ||
+        condition instanceof Date ||
+        Array.isArray(condition)) {
+        return `${col(field)} == ${lit(condition)}`;
+    }
+    const clauses = [];
+    for (const key of Reflect.ownKeys(condition)) {
+        clauses.push(compileOperator(field, opName(key), condition[key]));
+    }
+    return clauses.length > 1 ? `(${clauses.join(' and ')})` : clauses[0] ?? 'true';
+}
+function compileClause(where) {
+    const parts = [];
+    for (const key of Reflect.ownKeys(where)) {
+        const val = where[key];
+        const op = opName(key);
+        if (op === 'and') {
+            const arr = Array.isArray(val) ? val : [val];
+            parts.push(`(${arr.map((s) => compileClause(s)).join(' and ')})`);
+        }
+        else if (op === 'or') {
+            const arr = Array.isArray(val) ? val : [val];
+            parts.push(`(${arr.map((s) => compileClause(s)).join(' or ')})`);
+        }
+        else if (op === 'not') {
+            const arr = Array.isArray(val) ? val : [val];
+            parts.push(`not (${arr.map((s) => compileClause(s)).join(' and ')})`);
+        }
+        else if (typeof key === 'symbol') {
+            throw new FluxPushdownUnsupported(`operator ${op} without a field`);
+        }
+        else {
+            parts.push(compileField(key, val));
+        }
+    }
+    return parts.length > 1 ? `(${parts.join(' and ')})` : parts[0] ?? 'true';
+}
+/** Compile a where clause to a Flux `filter(fn: (r) => ...)` predicate body. */
+function compileFluxPredicate(where) {
+    return compileClause(where);
+}
+/** Compile an `order` spec to Flux `sort()` args: `columns: [...], desc: bool`. */
+function compileFluxSort(order) {
+    const entries = typeof order === 'string' ? [order] : order;
+    const columns = [];
+    let desc = false;
+    for (const entry of entries) {
+        if (typeof entry === 'string') {
+            columns.push(entry);
+        }
+        else {
+            columns.push(entry[0]);
+            desc = String(entry[1]).toUpperCase() === 'DESC';
+        }
+    }
+    return { columns, desc };
+}

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

@@ -0,0 +1,300 @@
+/**
+ * InfluxDB store implementation.
+ *
+ * InfluxDB is a time-series database: writes are append-only points
+ * (measurement + tags + fields + timestamp) expressed in line protocol,
+ * and reads are Flux scripts that stream back annotated CSV rows grouped
+ * into tables. There is no `JOIN`/`WHERE row = ...` update model, no
+ * transactions, and no schema beyond "a bucket accepts points" - none of
+ * which fits the SQL-shaped `Dialect` interface (`src/dialects/dialect.ts`).
+ * This class instead implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes InfluxDB's real write/query APIs
+ * directly.
+ *
+ * Uses the official `@influxdata/influxdb-client` driver (InfluxDB 2.x /
+ * InfluxDB Cloud, token + org + bucket auth, Flux query language).
+ *
+ * ## Write buffering - the #1 gotcha
+ *
+ * The client's `WriteApi` ALWAYS buffers written points/lines in memory
+ * and batches them to the server in the background (by `batchSize` or
+ * `flushInterval`, whichever comes first). Calling `writePoint`/
+ * `writePoints`/`writeRecord`/`writeRecords` returns immediately and does
+ * NOT guarantee the data has reached the server - a query issued right
+ * after can legitimately observe nothing yet. Call `flush()` (or
+ * `close()`, which flushes then releases the write API) to force pending
+ * points out. `disconnect()` below flushes and closes every write API
+ * this store has opened, so buffered points are never silently dropped
+ * on shutdown.
+ */
+import { InfluxDB, Point, type WriteApi, type WriteOptions, type WritePrecisionType, type Row, type FluxTableMetaData, type ParameterizedQuery } from '@influxdata/influxdb-client';
+import { NoSqlStore } from '../store';
+import { type WhereClause, type OrderSpec } from '../rocksdb/where-match';
+export { compileFluxPredicate, compileFluxSort, FluxPushdownUnsupported } from './flux-compiler';
+export type { WhereClause, OrderSpec } from '../rocksdb/where-match';
+/**
+ * Describes how a record maps onto InfluxDB's line-protocol shape: which
+ * keys are indexed tags, which key carries the timestamp, and integer-typed
+ * fields. Everything not named a tag or the time field becomes a value field.
+ */
+export interface InfluxMeasurementSchema {
+    /** Measurement (table) name. */
+    measurement: string;
+    /** Bucket to write to / read from. Falls back to the store's default bucket. */
+    bucket?: string;
+    /** Record keys to write as indexed tags (strings). */
+    tags?: string[];
+    /** Record key holding the point timestamp. Defaults to `'time'`. */
+    timeField?: string;
+    /** Field names to write as signed integers rather than floats. */
+    intFields?: string[];
+    /** Field names to write as unsigned integers rather than floats. */
+    uintFields?: string[];
+}
+/** A start/stop window for a Flux `range()`. Accepts durations, Dates, or epoch ms. */
+export interface InfluxTimeRange {
+    /** Range start: a Flux duration string (`'-30d'`), RFC3339 string, `Date`, or epoch ms. Defaults to the Unix epoch. */
+    start?: string | number | Date;
+    /** Range stop. Defaults to `now()`. */
+    stop?: string | number | Date;
+}
+/** Options for {@link InfluxDBStore.findAll} / {@link InfluxDBStore.findOne}. */
+export interface InfluxFindOptions {
+    /** Measurement to read from. */
+    measurement: string;
+    /** Bucket to read from. Falls back to the store's default bucket. */
+    bucket?: string;
+    /** Row filter. Tag and field predicates are pushed into Flux where possible. */
+    where?: WhereClause;
+    /** Sort spec. Defaults to ascending `_time`. */
+    order?: OrderSpec;
+    limit?: number;
+    offset?: number;
+    /** Time window. Defaults to all time (`epoch`..`now()`). */
+    range?: InfluxTimeRange;
+}
+/** Aggregate/downsample options for {@link InfluxDBStore.aggregate}. */
+export interface InfluxAggregateOptions {
+    measurement: string;
+    bucket?: string;
+    /** Field to aggregate. */
+    field: string;
+    /** Aggregate function: `mean`, `sum`, `min`, `max`, `count`, `first`, `last`, `median`, `stddev`. */
+    fn: 'mean' | 'sum' | 'min' | 'max' | 'count' | 'first' | 'last' | 'median' | 'stddev';
+    /** Tag predicate (applied before aggregation). */
+    where?: WhereClause;
+    /** Time window. */
+    range?: InfluxTimeRange;
+    /** Downsample window, e.g. `'1h'`. Uses `aggregateWindow` when set. */
+    window?: string;
+    /** Tags to group by before aggregating. */
+    groupBy?: string[];
+}
+export { Point } from '@influxdata/influxdb-client';
+export type { WriteApi, QueryApi, WriteOptions, WritePrecisionType, Row, FluxTableMetaData, ParameterizedQuery, } from '@influxdata/influxdb-client';
+/**
+ * Connection options for `InfluxDBStore`.
+ *
+ * `url`, `token`, and `org` are required - InfluxDB 2.x/Cloud auth is
+ * token-based and every write/query is scoped to an organization.
+ * `bucket` is optional here and is only used as the default bucket for
+ * convenience methods that don't take an explicit `bucket` override.
+ */
+export interface InfluxDBStoreOptions {
+    /** Base URL of the InfluxDB server/cloud instance, e.g. `http://localhost:8086`. */
+    url: string;
+    /** API token used for both writes and queries. */
+    token: string;
+    /** Organization (name or ID) that writes/queries are scoped to. */
+    org: string;
+    /** Default bucket used by convenience methods when no `bucket` override is given. */
+    bucket?: string;
+    /** Default timestamp precision for the write API. Defaults to `'ns'`. */
+    precision?: WritePrecisionType;
+    /** Socket timeout in milliseconds. Defaults to the client's own default (10000). */
+    timeout?: number;
+    /** Extra HTTP headers sent with every request. */
+    headers?: Record<string, string>;
+    /** Overrides for the write API's batching/retry behavior (batchSize, flushInterval, maxRetries, ...). */
+    writeOptions?: Partial<WriteOptions>;
+}
+/** Per-call override of bucket/org/precision for write operations. */
+export interface WriteScopeOptions {
+    /** Bucket to write into. Falls back to `InfluxDBStoreOptions.bucket`. */
+    bucket?: string;
+    /** Organization to write into. Falls back to `InfluxDBStoreOptions.org`. */
+    org?: string;
+    /** Timestamp precision for this write API instance. Falls back to `InfluxDBStoreOptions.precision`. */
+    precision?: WritePrecisionType;
+}
+/** Per-call override of org for query operations. */
+export interface QueryScopeOptions {
+    /** Organization to query against. Falls back to `InfluxDBStoreOptions.org`. */
+    org?: string;
+}
+/** Plain-object description of a point, for the `writeMeasurement`/`writeMeasurements` convenience methods. */
+export interface PointInput {
+    /** Measurement name. */
+    measurement: string;
+    /** Tag set (indexed, string-valued). */
+    tags?: Record<string, string>;
+    /**
+     * Field set (the actual values). `number` fields are written as floats
+     * unless `intFields`/`uintFields` name them explicitly - see
+     * `PointInput.intFields`/`uintFields`.
+     */
+    fields: Record<string, string | number | boolean>;
+    /** Names (subset of `fields`' keys) that should be written as signed integers instead of floats. */
+    intFields?: string[];
+    /** Names (subset of `fields`' keys) that should be written as unsigned integers instead of floats. */
+    uintFields?: string[];
+    /**
+     * Point timestamp. `undefined` (default) lets the client stamp it with
+     * the local clock; an explicit `Date`/`number`/string sets it; the
+     * empty string `''` omits it so the server assigns one on ingest.
+     */
+    timestamp?: Date | number | string;
+}
+/** A single row from a Flux query result, already converted to a plain object via its table metadata. */
+export type QueryRow = Record<string, unknown>;
+/**
+ * `InfluxDBStore` wraps `@influxdata/influxdb-client`'s `InfluxDB` client
+ * and exposes InfluxDB's write API (point/line-protocol writes, buffered
+ * with explicit flush/close) and query API (Flux, streamed row-by-row)
+ * as a typed, promise/async-iterable-based API.
+ */
+export declare class InfluxDBStore implements NoSqlStore {
+    readonly name = "influxdb";
+    readonly library = "@influxdata/influxdb-client";
+    private readonly options;
+    private client;
+    private connected;
+    private readonly writeApis;
+    private readonly queryApis;
+    constructor(options: InfluxDBStoreOptions);
+    /**
+     * Creates the underlying `InfluxDB` client and verifies the url/token/org
+     * combination by issuing a trivial Flux query (`buckets() |> limit(n:1)`).
+     * InfluxDB's HTTP client has no persistent socket to "connect", so this
+     * is the closest equivalent to the connect-time failure surfaced by
+     * socket-based stores (bad host, refused connection, invalid token/org).
+     */
+    connect(): Promise<void>;
+    /**
+     * Flushes and closes every write API opened by this store (so no
+     * buffered point is silently dropped), then drops the client.
+     */
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `InfluxDB` client for anything not wrapped here. */
+    getClient(): InfluxDB;
+    private requireClient;
+    private resolveBucket;
+    /**
+     * Returns the memoized `WriteApi` for the given (org, bucket, precision),
+     * creating it on first use. Returned instances buffer writes - see the
+     * write-buffering note in this file's header comment.
+     */
+    getWriteApi(scope?: WriteScopeOptions): WriteApi;
+    /** Write a single already-built `Point`. Buffered - call `flush()` to force delivery. */
+    writePoint(point: Point, scope?: WriteScopeOptions): void;
+    /** Write multiple already-built `Point`s. Buffered - call `flush()` to force delivery. */
+    writePoints(points: ArrayLike<Point>, scope?: WriteScopeOptions): void;
+    /** Write a single raw line-protocol record. Buffered - call `flush()` to force delivery. */
+    writeRecord(record: string, scope?: WriteScopeOptions): void;
+    /** Write multiple raw line-protocol records. Buffered - call `flush()` to force delivery. */
+    writeRecords(records: string[], scope?: WriteScopeOptions): void;
+    /** Convenience: build a `Point` from a plain object and write it. */
+    writeMeasurement(input: PointInput, scope?: WriteScopeOptions): void;
+    /** Convenience: build and write a batch of `Point`s from plain objects. */
+    writeMeasurements(inputs: PointInput[], scope?: WriteScopeOptions): void;
+    /**
+     * Flushes the write API for the given scope, sending any buffered
+     * points/lines to the server immediately. Resolves once the flush
+     * completes (or immediately if nothing was ever written for that scope).
+     */
+    flush(scope?: WriteScopeOptions): Promise<void>;
+    /** Flushes every write API this store has opened, across all buckets/orgs/precisions. */
+    flushAll(): Promise<void>;
+    /**
+     * Flushes and closes the write API for the given scope, releasing it so
+     * a subsequent write for the same scope opens a fresh one.
+     */
+    closeWriteApi(scope?: WriteScopeOptions): Promise<void>;
+    private getQueryApi;
+    /**
+     * Streams a Flux query's result rows, already converted to plain
+     * objects via each row's table metadata (equivalent to
+     * `tableMeta.toObject(row.values)`). Suitable for `for-await` loops
+     * over large result sets without buffering everything in memory.
+     */
+    query(fluxQuery: string | ParameterizedQuery, scope?: QueryScopeOptions): AsyncIterable<QueryRow>;
+    /**
+     * Streams a Flux query's raw `Row`s (values + table metadata),
+     * without the `toObject` conversion `query()` applies.
+     */
+    queryRows(fluxQuery: string | ParameterizedQuery, scope?: QueryScopeOptions): AsyncIterable<Row>;
+    /**
+     * Executes a Flux query and collects every result row into an array via
+     * the returned Promise. Use with caution on large result sets - the
+     * whole result is buffered in memory. Prefer `query()`/`queryRows()`
+     * for streaming.
+     */
+    collectRows<T = QueryRow>(fluxQuery: string | ParameterizedQuery, rowMapper?: (values: string[], tableMeta: FluxTableMetaData) => T | undefined, scope?: QueryScopeOptions): Promise<T[]>;
+    /** Executes a Flux query and returns the full annotated-CSV response as a string. */
+    queryRaw(fluxQuery: string | ParameterizedQuery, scope?: QueryScopeOptions): Promise<string>;
+    /** Render a time-range bound as a Flux time/duration literal. */
+    private static fluxTime;
+    private static escapeFlux;
+    /**
+     * ORM `create`: model one record as a line-protocol point per `schema`
+     * (tags vs fields vs timestamp) and write it. Buffered - this method flushes
+     * so the point is durable before it resolves.
+     */
+    create(schema: InfluxMeasurementSchema, record: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** ORM `bulkCreate`: write many records as points, then flush. */
+    bulkCreate(schema: InfluxMeasurementSchema, records: Array<Record<string, unknown>>): Promise<Array<Record<string, unknown>>>;
+    /** Build the base Flux for a measurement read (range + measurement filter + pivot). */
+    private buildBaseFlux;
+    /**
+     * ORM `findAll`. Generates Flux from `measurement`/`where`/`order`/`range`;
+     * `where` predicates are pushed into Flux when expressible, otherwise the
+     * rows are collected and filtered in memory with the shared matcher.
+     * `limit`/`offset` are applied to the (sorted) result.
+     */
+    findAll<T = QueryRow>(options: InfluxFindOptions): Promise<T[]>;
+    /** ORM `findOne`: the first row matching `where` (respecting order). */
+    findOne<T = QueryRow>(options: InfluxFindOptions): Promise<T | null>;
+    /** ORM `count`: number of points/rows matching the query. */
+    count(options: InfluxFindOptions): Promise<number>;
+    /**
+     * Aggregate (and optionally downsample) a field. Generates Flux using either
+     * a bare aggregate (`mean()`, `sum()`, ...) or `aggregateWindow(every, fn)`
+     * when `window` is set, grouping by `groupBy` tags first. Returns the result
+     * rows so callers never hand-write Flux for standard aggregates.
+     */
+    aggregate<T = QueryRow>(options: InfluxAggregateOptions): Promise<T[]>;
+    /**
+     * ORM `update` is unsupported: InfluxDB points are immutable, so there is no
+     * safe in-place row update to emulate. Write a new point (`create`) with the
+     * corrected values instead, or delete + rewrite via {@link destroy}. Throws
+     * a typed capability error rather than silently doing nothing.
+     */
+    update(): Promise<never>;
+    /**
+     * ORM `destroy`: delete points from `measurement` within a time range,
+     * optionally narrowed by an equality predicate on tags. Uses InfluxDB's
+     * delete API (from the optional `@influxdata/influxdb-client-apis` package,
+     * required lazily). `where` supports only equality on tags/`_measurement`/
+     * `_field` - the delete API's predicate grammar - and throws a typed error
+     * for anything else, since a Flux-style filter cannot be emulated safely here.
+     */
+    destroy(options: {
+        measurement: string;
+        bucket?: string;
+        where?: WhereClause;
+        range?: InfluxTimeRange;
+    }): Promise<void>;
+    /** Build a delete-API predicate string (equality-only) from a where clause. */
+    private static buildDeletePredicate;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * Apache Kafka store implementation.
+ *
+ * Kafka is a distributed, partitioned, append-only commit log used as a
+ * message broker / event-streaming platform. It has no query language and
+ * does not fit the SQL-shaped `Dialect` interface, so this class implements
+ * the minimal `NoSqlStore` marker interface and exposes Kafka's real
+ * operations - producing to topics, creating/listing topics via the admin
+ * client, and subscribing consumers to topics - instead of forcing
+ * everything into a `query(sql)` shape.
+ *
+ * Uses the `kafkajs` driver. `kafkajs` is loaded lazily inside `connect()`
+ * (or supplied pre-built via `options.client`) so importing this module does
+ * not require the driver to be installed.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * SASL authentication options passed straight through to kafkajs.
+ */
+export interface KafkaSaslOptions {
+    mechanism: string;
+    username: string;
+    password: string;
+    [key: string]: unknown;
+}
+/**
+ * Connection options for `KafkaStore`.
+ *
+ * Mirrors kafkajs's `Kafka` constructor options. `brokers` is the list of
+ * `host:port` seed brokers. A pre-built kafkajs `Kafka` instance can be
+ * injected via `client`, in which case `connect()` uses it directly and
+ * skips loading the driver (this is how tests inject a mock).
+ */
+export interface KafkaStoreOptions {
+    /** Client identifier reported to the broker. */
+    clientId?: string;
+    /** Seed broker list, e.g. `['localhost:9092']`. */
+    brokers?: string[];
+    /** Enable TLS, or pass a kafkajs TLS options object. */
+    ssl?: boolean | Record<string, unknown>;
+    /** SASL authentication configuration. */
+    sasl?: KafkaSaslOptions;
+    /**
+     * A pre-built kafkajs `Kafka` instance. When provided, `connect()` uses it
+     * directly and does not `require('kafkajs')`.
+     */
+    client?: any;
+}
+/** A single message to produce to a topic. */
+export interface KafkaMessage {
+    key?: string | Buffer | null;
+    value: string | Buffer | null;
+    partition?: number;
+    headers?: Record<string, string | Buffer>;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/** Options for `createTopic()`. */
+export interface CreateTopicOptions {
+    numPartitions?: number;
+    replicationFactor?: number;
+}
+/** Options for `subscribe()`. */
+export interface SubscribeOptions {
+    /** Consumer group id. Defaults to a generated id. */
+    groupId?: string;
+    /** Consume from the beginning of the topic rather than the latest offset. */
+    fromBeginning?: boolean;
+}
+/**
+ * `KafkaStore` wraps a `kafkajs` client and exposes Kafka's core operations:
+ * producing messages, topic administration, and consumer subscriptions.
+ */
+export declare class KafkaStore implements NoSqlStore {
+    readonly name = "kafka";
+    readonly library = "kafkajs";
+    private readonly options;
+    private client;
+    private producer;
+    /** Consumers created via `subscribe()`, tracked so `disconnect()` can stop them all. */
+    private readonly consumers;
+    private connected;
+    constructor(options?: KafkaStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `kafkajs` `Kafka` client for anything not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    private requireProducer;
+    /**
+     * Produce one or more messages to `topic`. Returns kafkajs's record
+     * metadata (per-partition base offsets).
+     */
+    produce(topic: string, messages: KafkaMessage[]): Promise<any>;
+    /**
+     * Create `topic` via a short-lived admin connection. Returns kafkajs's
+     * boolean indicating whether the topic was newly created (`false` if it
+     * already existed).
+     */
+    createTopic(topic: string, opts?: CreateTopicOptions): Promise<boolean>;
+    /** List all topic names known to the cluster via a short-lived admin connection. */
+    listTopics(): Promise<string[]>;
+    /**
+     * Subscribe a new consumer to `topics` and invoke `handler` for each
+     * message (kafkajs's `eachMessage` payload: `{ topic, partition, message }`).
+     * The consumer joins the group `options.groupId` (a generated id is used if
+     * omitted) and is tracked so `disconnect()` stops it. Returns the created
+     * kafkajs consumer.
+     */
+    subscribe(topics: string | string[], handler: (payload: any) => Promise<void> | void, options?: SubscribeOptions): Promise<any>;
+}
+export default KafkaStore;