ts-prorm-orm 1.1.0 → 1.2.0

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

@@ -0,0 +1,143 @@
+/**
+ * ProvenDB store implementation.
+ *
+ * ProvenDB is a MongoDB-compatible database that adds immutable, versioned
+ * documents plus cryptographic proofs: every write is captured at a
+ * monotonically increasing **version**, and ProvenDB can produce a Merkle
+ * proof that a document (or a whole query result) existed at a given version,
+ * anchored into a public blockchain. That makes it append-only/auditable on
+ * top of a familiar document API.
+ *
+ * ## HTTP proof API over `fetch`
+ *
+ * While ProvenDB exposes a Mongo wire protocol, its distinguishing feature -
+ * versioned documents and proofs - is surfaced here over its REST/HTTP proof
+ * API using the global `fetch` (so `library === 'fetch'`), matching the
+ * Prometheus store's injectable-client pattern. This class implements the
+ * minimal `NoSqlStore` marker interface plus the shared ledger surface:
+ *  - `append(collection, data)` -> `POST /collections/<c>/documents`.
+ *  - `get(collection, id)`      -> `GET /collections/<c>/documents/<id>`.
+ *  - `history(collection, id)`  -> `GET .../documents/<id>/versions`.
+ *  - `verify(collection, id)`   -> `POST .../documents/<id>/proof` (returns
+ *    the Merkle proof + blockchain anchor).
+ *  - `query(filter)`            -> `POST /collections/<c>/query`.
+ */
+import { NoSqlStore } from '../store';
+/** Default ProvenDB HTTP API base URL. */
+export declare const DEFAULT_PROVENDB_BASE_URL = "http://localhost:8080";
+/** The subset of an HTTP client this store needs (GET + POST returning JSON). */
+export interface ProvendbHttpClient {
+    get(path: string): Promise<any>;
+    post(path: string, body?: unknown): Promise<any>;
+}
+/** Connection options for `ProvendbStore`. */
+export interface ProvendbStoreOptions {
+    /** Base URL of the ProvenDB HTTP API. Defaults to `http://localhost:8080`. */
+    baseURL?: string;
+    /** Optional pre-built HTTP client; when provided, `baseURL` is ignored. */
+    client?: ProvendbHttpClient;
+    /** Extra HTTP headers (e.g. an API token). */
+    headers?: Record<string, string>;
+}
+/** Build a `fetch`-backed JSON client for the given base URL. */
+export declare function createProvendbFetchClient(baseURL: string, headers?: Record<string, string>): ProvendbHttpClient;
+/** Sort direction accepted by {@link ProvendbStore.findAll}'s `order`. */
+export type ProvendbOrderDirection = 'ASC' | 'DESC' | 'asc' | 'desc';
+/** Options for {@link ProvendbStore.findAll}/{@link ProvendbStore.findOne}. */
+export interface ProvendbFindOptions {
+    /** ORM `where` clause (plain equality and/or `Op`-keyed conditions). */
+    where?: Record<string, any>;
+    /** Restrict returned fields, e.g. `['name', 'email']` (Mongo projection). */
+    attributes?: string[];
+    /** Ordering, e.g. `[['age', 'DESC'], ['name', 'ASC']]`. */
+    order?: Array<[string, ProvendbOrderDirection]>;
+    /** Maximum number of documents to return. */
+    limit?: number;
+    /** Number of documents to skip. */
+    offset?: number;
+    /**
+     * Read the collection as of a historical ProvenDB `version` (its
+     * versioned/point-in-time feature) instead of the current state.
+     */
+    version?: number | string;
+}
+/**
+ * `ProvendbStore` wraps ProvenDB's HTTP proof/document API behind the shared
+ * ledger surface.
+ */
+export declare class ProvendbStore implements NoSqlStore {
+    readonly name = "provendb";
+    readonly library = "fetch";
+    private readonly baseURL;
+    private readonly injectedClient?;
+    private readonly headers?;
+    private client;
+    private connected;
+    constructor(options?: ProvendbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying (internal or injected) HTTP client. */
+    getClient(): ProvendbHttpClient;
+    private requireClient;
+    private call;
+    /**
+     * Insert `data` into `collection` at a new version
+     * (`POST /collections/<c>/documents`). Returns the inserted document
+     * (including its `_id` and `_version`).
+     */
+    append(collection: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Read the current version of document `id` from `collection`. */
+    get(collection: string, id: string): Promise<unknown>;
+    /** Return every version of document `id` (`GET .../documents/<id>/versions`). */
+    history(collection: string, id: string): Promise<unknown>;
+    /**
+     * Request a cryptographic proof for document `id`
+     * (`POST .../documents/<id>/proof`). The returned object contains the
+     * Merkle proof and the public-blockchain anchor that tamper-proofs the
+     * document's state at its version.
+     */
+    verify(collection: string, id: string): Promise<unknown>;
+    /**
+     * Run a Mongo-style filter query against `collection`
+     * (`POST /collections/<c>/query`). `query` is the Mongo filter document;
+     * `options` carries projection/sort/limit and an optional historical
+     * `version`.
+     */
+    query(collection: string, query?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Fetch every document in `collection` matching the ORM `where` clause. The
+     * `where` is compiled to a MongoDB filter; `attributes`/`order`/`limit`/
+     * `offset` become the `projection`/`sort`/`limit`/`skip` query options, and
+     * `version` (if given) reads the collection at a historical ProvenDB
+     * version.
+     */
+    findAll<T = Record<string, unknown>>(collection: string, options?: ProvendbFindOptions): Promise<T[]>;
+    /** Fetch the first document matching `where` (Mongo `limit 1`), or `null`. */
+    findOne<T = Record<string, unknown>>(collection: string, options?: ProvendbFindOptions): Promise<T | null>;
+    /** Count documents in `collection` matching `where`. */
+    count(collection: string, where?: Record<string, any>): Promise<number>;
+    /** Insert `data` as a new versioned document. Alias of {@link append}. */
+    create(collection: string, data: Record<string, unknown>): Promise<unknown>;
+    /** Insert many documents (one versioned write per document), returning them. */
+    bulkCreate(collection: string, docs: Array<Record<string, unknown>>): Promise<unknown[]>;
+    /**
+     * Update every document matching `where`, `$set`ting each key in `values`.
+     * Returns the raw ProvenDB response (which records the new version the
+     * write was captured at).
+     */
+    update(collection: string, values: Record<string, unknown>, where?: Record<string, any>, options?: {
+        upsert?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Insert-or-update: update documents matching `where` with `data`, creating
+     * a new document if none match (`upsert: true`).
+     */
+    upsert(collection: string, data: Record<string, unknown>, where: Record<string, any>): Promise<unknown>;
+    /**
+     * Delete every document matching `where`. ProvenDB retains prior versions,
+     * so deleted documents remain recoverable via {@link history}.
+     */
+    destroy(collection: string, where?: Record<string, any>): Promise<unknown>;
+}
+export default ProvendbStore;

package/dist/nosql/provendb/index.js

@@ -51,6 +51,182 @@ function createProvendbFetchClient(baseURL, headers) {
         },
     };
 }
+/** Parse an ORM `where` object (string + `Op` symbol keys) into a tree. */
+function parseWhere(where) {
+    if (!where || typeof where !== 'object')
+        return null;
+    const nodes = [];
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const name = sym.description;
+        const val = where[sym];
+        if (name === 'and' && Array.isArray(val)) {
+            nodes.push({ kind: 'and', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'or' && Array.isArray(val)) {
+            nodes.push({ kind: 'or', nodes: val.map(parseWhere).filter(Boolean) });
+        }
+        else if (name === 'not') {
+            const inner = parseWhere(val);
+            if (inner)
+                nodes.push({ kind: 'not', node: inner });
+        }
+    }
+    for (const field of Object.keys(where)) {
+        nodes.push(parseFieldCondition(field, where[field]));
+    }
+    const flat = nodes.filter(Boolean);
+    if (flat.length === 0)
+        return null;
+    return flat.length === 1 ? flat[0] : { kind: 'and', nodes: flat };
+}
+/** Parse the value for a single field into a comparison (or AND of them). */
+function parseFieldCondition(field, value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const symbols = Object.getOwnPropertySymbols(value);
+        if (symbols.length > 0) {
+            const cmps = symbols.map((sym) => ({
+                kind: 'cmp',
+                field,
+                op: sym.description ?? 'eq',
+                value: value[sym],
+            }));
+            return cmps.length === 1 ? cmps[0] : { kind: 'and', nodes: cmps };
+        }
+    }
+    return { kind: 'cmp', field, op: value === null ? 'isNull' : 'eq', value };
+}
+/** Escape a string for safe embedding in a MongoDB `$regex` pattern. */
+function escapeRegex(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Convert a SQL `LIKE` pattern (`%`/`_` wildcards) to a Mongo regex source. */
+function likeToRegex(pattern) {
+    let out = '^';
+    for (const ch of String(pattern)) {
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    return out + '$';
+}
+/** Render a normalized tree to a MongoDB filter document. */
+function compileMongoFilter(node) {
+    if (!node)
+        return {};
+    switch (node.kind) {
+        case 'and': {
+            const parts = node.nodes.map(compileMongoFilter).filter((p) => Object.keys(p).length > 0);
+            return parts.length === 0 ? {} : parts.length === 1 ? parts[0] : { $and: parts };
+        }
+        case 'or': {
+            const parts = node.nodes.map(compileMongoFilter);
+            return { $or: parts };
+        }
+        case 'not':
+            return { $nor: [compileMongoFilter(node.node)] };
+        case 'cmp':
+            return compileMongoCmp(node.field, node.op, node.value);
+    }
+}
+function compileMongoCmp(field, op, value) {
+    switch (op) {
+        case 'eq':
+            return { [field]: value };
+        case 'ne':
+            return { [field]: { $ne: value } };
+        case 'gt':
+            return { [field]: { $gt: value } };
+        case 'gte':
+            return { [field]: { $gte: value } };
+        case 'lt':
+            return { [field]: { $lt: value } };
+        case 'lte':
+            return { [field]: { $lte: value } };
+        case 'in':
+            return { [field]: { $in: value ?? [] } };
+        case 'notIn':
+            return { [field]: { $nin: value ?? [] } };
+        case 'between': {
+            const [a, b] = value;
+            return { [field]: { $gte: a, $lte: b } };
+        }
+        case 'notBetween': {
+            const [a, b] = value;
+            return { [field]: { $not: { $gte: a, $lte: b } } };
+        }
+        case 'like':
+            return { [field]: { $regex: likeToRegex(value) } };
+        case 'notLike':
+            return { [field]: { $not: { $regex: likeToRegex(value) } } };
+        case 'iLike':
+            return { [field]: { $regex: likeToRegex(value), $options: 'i' } };
+        case 'notILike':
+            return { [field]: { $not: { $regex: likeToRegex(value), $options: 'i' } } };
+        case 'startsWith':
+            return { [field]: { $regex: `^${escapeRegex(value)}` } };
+        case 'notStartsWith':
+            return { [field]: { $not: { $regex: `^${escapeRegex(value)}` } } };
+        case 'endsWith':
+            return { [field]: { $regex: `${escapeRegex(value)}$` } };
+        case 'notEndsWith':
+            return { [field]: { $not: { $regex: `${escapeRegex(value)}$` } } };
+        case 'substring':
+            return { [field]: { $regex: escapeRegex(value) } };
+        case 'notSubstring':
+            return { [field]: { $not: { $regex: escapeRegex(value) } } };
+        case 'regexp':
+            return { [field]: { $regex: String(value) } };
+        case 'notRegexp':
+            return { [field]: { $not: { $regex: String(value) } } };
+        case 'iRegexp':
+            return { [field]: { $regex: String(value), $options: 'i' } };
+        case 'notIRegexp':
+            return { [field]: { $not: { $regex: String(value), $options: 'i' } } };
+        case 'isNull':
+            return { [field]: { $eq: null } };
+        case 'isNotNull':
+            return { [field]: { $ne: null } };
+        case 'contains':
+        case 'arrayContains':
+            return { [field]: { $all: Array.isArray(value) ? value : [value] } };
+        default:
+            throw new errors_1.DatabaseError(`ProvenDB ORM layer does not support operator "${op}" for field "${field}"`, { code: 'QUERY_ERROR' });
+    }
+}
+/** Build a Mongo projection object from an ORM `attributes` list. */
+function toProjection(attributes) {
+    if (!attributes || attributes.length === 0)
+        return undefined;
+    const projection = {};
+    for (const attr of attributes)
+        projection[attr] = 1;
+    return projection;
+}
+/** Build a Mongo sort object from an ORM `order` list. */
+function toSort(order) {
+    if (!order || order.length === 0)
+        return undefined;
+    const sort = {};
+    for (const [field, dir] of order)
+        sort[field] = dir.toUpperCase() === 'DESC' ? -1 : 1;
+    return sort;
+}
+/** Normalize a ProvenDB query response into a plain array of documents. */
+function extractDocs(res) {
+    if (Array.isArray(res))
+        return res;
+    if (res && typeof res === 'object') {
+        const obj = res;
+        for (const key of ['documents', 'data', 'results', 'items']) {
+            if (Array.isArray(obj[key]))
+                return obj[key];
+        }
+    }
+    return [];
+}
 /**
  * `ProvendbStore` wraps ProvenDB's HTTP proof/document API behind the shared
  * ledger surface.
@@ -142,6 +318,92 @@ class ProvendbStore {
     async query(collection, query = {}, options) {
         return this.call('query', (client) => client.post(`/collections/${encodeURIComponent(collection)}/query`, { query, options }));
     }
+    // ---------------------------------------------------------------------
+    // ORM model surface (no hand-written Mongo filters needed)
+    // ---------------------------------------------------------------------
+    /**
+     * Fetch every document in `collection` matching the ORM `where` clause. The
+     * `where` is compiled to a MongoDB filter; `attributes`/`order`/`limit`/
+     * `offset` become the `projection`/`sort`/`limit`/`skip` query options, and
+     * `version` (if given) reads the collection at a historical ProvenDB
+     * version.
+     */
+    async findAll(collection, options = {}) {
+        const filter = compileMongoFilter(parseWhere(options.where));
+        const queryOptions = {};
+        const projection = toProjection(options.attributes);
+        const sort = toSort(options.order);
+        if (projection)
+            queryOptions.projection = projection;
+        if (sort)
+            queryOptions.sort = sort;
+        if (typeof options.limit === 'number')
+            queryOptions.limit = options.limit;
+        if (typeof options.offset === 'number')
+            queryOptions.skip = options.offset;
+        if (options.version !== undefined)
+            queryOptions.version = options.version;
+        const res = await this.query(collection, filter, queryOptions);
+        return extractDocs(res);
+    }
+    /** Fetch the first document matching `where` (Mongo `limit 1`), or `null`. */
+    async findOne(collection, options = {}) {
+        const rows = await this.findAll(collection, { ...options, limit: 1 });
+        return rows[0] ?? null;
+    }
+    /** Count documents in `collection` matching `where`. */
+    async count(collection, where) {
+        const filter = compileMongoFilter(parseWhere(where));
+        const res = await this.call('count', (client) => client.post(`/collections/${encodeURIComponent(collection)}/count`, { query: filter }));
+        if (typeof res === 'number')
+            return res;
+        const obj = (res ?? {});
+        const n = obj.count ?? obj.n ?? obj.total;
+        return typeof n === 'number' ? n : extractDocs(res).length;
+    }
+    /** Insert `data` as a new versioned document. Alias of {@link append}. */
+    async create(collection, data) {
+        return this.append(collection, data);
+    }
+    /** Insert many documents (one versioned write per document), returning them. */
+    async bulkCreate(collection, docs) {
+        const out = [];
+        for (const doc of docs) {
+            out.push(await this.append(collection, doc));
+        }
+        return out;
+    }
+    /**
+     * Update every document matching `where`, `$set`ting each key in `values`.
+     * Returns the raw ProvenDB response (which records the new version the
+     * write was captured at).
+     */
+    async update(collection, values, where, options = {}) {
+        const filter = compileMongoFilter(parseWhere(where));
+        return this.call('update', (client) => client.post(`/collections/${encodeURIComponent(collection)}/update`, {
+            query: filter,
+            update: { $set: values },
+            options: { multi: true, upsert: options.upsert ?? false },
+        }));
+    }
+    /**
+     * Insert-or-update: update documents matching `where` with `data`, creating
+     * a new document if none match (`upsert: true`).
+     */
+    async upsert(collection, data, where) {
+        return this.update(collection, data, where, { upsert: true });
+    }
+    /**
+     * Delete every document matching `where`. ProvenDB retains prior versions,
+     * so deleted documents remain recoverable via {@link history}.
+     */
+    async destroy(collection, where) {
+        const filter = compileMongoFilter(parseWhere(where));
+        return this.call('destroy', (client) => client.post(`/collections/${encodeURIComponent(collection)}/delete`, {
+            query: filter,
+            options: { multi: true },
+        }));
+    }
 }
 exports.ProvendbStore = ProvendbStore;
 exports.default = ProvendbStore;

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

@@ -0,0 +1,83 @@
+import type { NoSqlStore } from '../store';
+/** A message accepted by `publish()`: raw string/Buffer or a JSON-serializable value. */
+export type PubSubMessage = string | Buffer | Record<string, unknown> | unknown[];
+/** Minimal structural view of a Pub/Sub `Topic`. */
+export interface PubSubTopicLike {
+    publishMessage(message: {
+        data?: Buffer;
+        attributes?: Record<string, string>;
+    }): Promise<string>;
+}
+/** Minimal structural view of a Pub/Sub `Subscription`. */
+export interface PubSubSubscriptionLike {
+    on(event: string, listener: (...args: any[]) => void): PubSubSubscriptionLike;
+    removeAllListeners?(event?: string): void;
+    close?(): Promise<void>;
+}
+/** Minimal structural view of a `@google-cloud/pubsub` `PubSub` client. */
+export interface PubSubClientLike {
+    topic(name: string): PubSubTopicLike;
+    subscription(name: string): PubSubSubscriptionLike;
+    createTopic(name: string): Promise<any>;
+    createSubscription(topic: string, name: string, options?: unknown): Promise<any>;
+    close?(): Promise<void>;
+}
+/** Connection options for `PubSubStore`. */
+export interface PubSubStoreOptions {
+    /** GCP project id. */
+    projectId?: string;
+    /** Path to a service-account key file. */
+    keyFilename?: string;
+    /** Override the API endpoint (e.g. 'localhost:8085' for the emulator). */
+    apiEndpoint?: string;
+    /**
+     * A pre-built `PubSub` client (or a mock exposing the methods above). When
+     * provided, `connect()` uses it directly and does NOT require the driver —
+     * this is how tests inject a mock client.
+     */
+    client?: PubSubClientLike;
+}
+/** A handle returned by `subscribe()`; call `stop()` to detach the listener. */
+export interface PubSubSubscription {
+    stop(): Promise<void>;
+}
+/**
+ * `PubSubStore` wraps a `@google-cloud/pubsub` client and exposes topic
+ * publishing, subscription listening, and topic/subscription administration.
+ */
+export declare class PubSubStore implements NoSqlStore {
+    readonly name = "pubsub";
+    readonly library = "@google-cloud/pubsub";
+    private readonly options;
+    private client;
+    private connected;
+    /** Subscription objects that have live listeners, tracked for `disconnect()`. */
+    private readonly subscriptions;
+    constructor(options?: PubSubStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `PubSub` client for anything not wrapped here. */
+    getClient(): PubSubClientLike;
+    private requireClient;
+    private wrapError;
+    /**
+     * Publish one `message` to `topic` via `topic(name).publishMessage`. The
+     * message is encoded per the module's rules (string → UTF-8, Buffer → as-is,
+     * else JSON). Returns the server-assigned message id.
+     */
+    publish(topic: string, message: PubSubMessage, attributes?: Record<string, string>): Promise<string>;
+    /** `createTopic` — create a new topic. */
+    createTopic(name: string): Promise<void>;
+    /** `createSubscription` — attach a new subscription `name` to `topic`. */
+    createSubscription(topic: string, name: string, options?: unknown): Promise<void>;
+    /**
+     * Subscribe to `subscription`, invoking `handler` for each streamed message
+     * (the driver's `Message` object; call `.ack()` / `.nack()` on it). Attaches
+     * a `'message'` listener via `subscription(name).on('message', ...)` and
+     * returns a subscription handle whose `stop()` detaches the listener; it is
+     * also tracked so `disconnect()` detaches it.
+     */
+    subscribe(subscription: string, handler: (message: any) => void | Promise<void>): Promise<PubSubSubscription>;
+}
+export default PubSubStore;

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

@@ -0,0 +1,105 @@
+/**
+ * Apache Pulsar store implementation.
+ *
+ * Pulsar is a distributed pub/sub messaging and 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
+ * Pulsar's real operations - producing to topics, subscribing consumers, and
+ * creating readers - instead of forcing everything into a `query(sql)` shape.
+ *
+ * Uses the `pulsar-client` driver. `pulsar-client` is loaded lazily inside
+ * `connect()` (or supplied pre-built via `options.client`) so importing this
+ * module does not require the driver to be installed.
+ *
+ * ## Message serialization
+ *
+ * Pulsar sends and receives raw bytes. `produce()` accepts a `string` or a
+ * `Buffer`: strings are UTF-8 encoded to a `Buffer` and Buffers are passed
+ * through untouched, then handed to the producer as `{ data: Buffer }`.
+ * Consumers receive Pulsar `Message` objects; use `msg.getData()` to read the
+ * raw bytes back.
+ */
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `PulsarStore`.
+ *
+ * Mirrors the `pulsar-client` `Client` constructor options. `serviceUrl` is
+ * the Pulsar broker URL, e.g. `pulsar://localhost:6650`. A pre-built
+ * `pulsar-client` `Client` 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 PulsarStoreOptions {
+    /** Pulsar broker service URL, e.g. `pulsar://localhost:6650`. */
+    serviceUrl?: string;
+    /**
+     * A pre-built `pulsar-client` `Client` instance. When provided, `connect()`
+     * uses it directly and does not `require('pulsar-client')`.
+     */
+    client?: any;
+    /** Any additional `pulsar-client` `Client` options passed straight through. */
+    [key: string]: unknown;
+}
+/** A message body to produce: a UTF-8 string or raw bytes. */
+export type PulsarMessage = string | Buffer;
+/** Options for `subscribe()`. */
+export interface SubscribeOptions {
+    /** Subscription type, e.g. 'Exclusive' | 'Shared' | 'Failover' | 'KeyShared'. */
+    subscriptionType?: string;
+    [key: string]: unknown;
+}
+/** Options for `createReader()`. */
+export interface ReaderOptions {
+    /** Where the reader starts, e.g. Pulsar's `MessageId.earliest()` / `latest()`. */
+    startMessageId?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * `PulsarStore` wraps a `pulsar-client` `Client` and exposes Pulsar's core
+ * operations: producing messages, consumer subscriptions, and readers.
+ */
+export declare class PulsarStore implements NoSqlStore {
+    readonly name = "pulsar";
+    readonly library = "pulsar-client";
+    private readonly options;
+    private client;
+    /** One cached producer per topic, so repeated `produce()` calls reuse it. */
+    private readonly producers;
+    /** Consumers created via `subscribe()`, tracked so `disconnect()` can close them. */
+    private readonly consumers;
+    /** Readers created via `createReader()`, tracked so `disconnect()` can close them. */
+    private readonly readers;
+    /** Set false on `disconnect()` to stop live `subscribe()` receive loops. */
+    private receiving;
+    private connected;
+    constructor(options?: PulsarStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `pulsar-client` `Client` for anything not wrapped here. */
+    getClient(): any;
+    private requireClient;
+    /**
+     * Produce `message` to `topic`. The producer for a topic is created on first
+     * use and cached, so repeated `produce()` calls to the same topic reuse it.
+     * `message` may be a UTF-8 `string` or a `Buffer`; it is serialized to raw
+     * bytes and sent as `{ data: Buffer }`. Returns the producer's send result.
+     */
+    produce(topic: string, message: PulsarMessage): Promise<any>;
+    /**
+     * Subscribe a consumer to `topic` under `subscription` and invoke `handler`
+     * for every received message. Runs a background receive loop that calls
+     * `consumer.receive()`, passes each message to `handler`, then
+     * acknowledges it with `consumer.acknowledge(msg)`. The loop stops on
+     * `disconnect()`. The consumer is tracked so `disconnect()` closes it.
+     * Returns the created consumer.
+     */
+    subscribe(topic: string, subscription: string, handler: (msg: any) => Promise<void> | void, options?: SubscribeOptions): Promise<any>;
+    /**
+     * Create a Pulsar reader over `topic`. Readers give non-destructive,
+     * position-controlled reads (no subscription/acks). The reader is tracked so
+     * `disconnect()` closes it. Returns the created reader.
+     */
+    createReader(topic: string, options?: ReaderOptions): Promise<any>;
+}
+export default PulsarStore;