equipped 5.2.8 → 5.3.0-alpha.0

package/dist/types/dbs/adapters/mongodb/index.js

@@ -0,0 +1,418 @@
+import {
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe
+} from "../../../chunk-JZ2JTENY.js";
+import "../../../chunk-IAHTILKJ.js";
+import {
+  EquippedError,
+  Instance,
+  retry
+} from "../../../chunk-32DMHN3G.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/dbs/adapters/mongodb/changes.ts
+import "mongodb";
+import { differ } from "valleyed";
+
+// src/dbs/adapters/base/changes.ts
+import axios from "axios";
+import { v } from "valleyed";
+var TopicPrefix = "db-changes";
+var DbChange = class {
+  constructor(config, callbacks, mapper) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.mapper = mapper;
+    this.config = v.assert(dbChangeConfigPipe(), config);
+  }
+  async configureConnector(key, data) {
+    const instance = axios.create({ baseURL: this.config.debeziumUrl });
+    return await instance.put(`/connectors/${key}/config`, {
+      "topic.prefix": TopicPrefix,
+      "topic.creation.enable": "false",
+      "topic.creation.default.replication.factor": `-1`,
+      "topic.creation.default.partitions": "-1",
+      "key.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "key.converter.schemas.enable": "false",
+      "value.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "value.converter.schemas.enable": "false",
+      ...data
+    }).then(async () => {
+      const topics = await instance.get(`/connectors/${key}/topics`);
+      return topics.data[key]?.topics?.includes?.(key) ?? false;
+    }).catch((err) => {
+      throw new EquippedError(`Failed to configure watcher`, { key }, err);
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/changes.ts
+var MongoDbChange = class extends DbChange {
+  #started = false;
+  constructor(config, change, collection, callbacks, mapper) {
+    super(change, callbacks, mapper);
+    const hydrate = (data) => data._id ? {
+      ...data,
+      _id: data._id["$oid"] ?? data._id
+    } : void 0;
+    const dbName = collection.dbName;
+    const colName = collection.collectionName;
+    const dbColName = `${dbName}.${colName}`;
+    const topic = `${TopicPrefix}.${dbColName}`;
+    const TestId = "5f5f65717569707065645f5f";
+    const condition = { _id: TestId };
+    change.eventBus.stream(topic, { skipScope: true }).subscribe(async (data) => {
+      const op = data.op;
+      let before = JSON.parse(data.before ?? "null");
+      let after = JSON.parse(data.after ?? "null");
+      if (before) before = hydrate(before);
+      if (after) after = hydrate(after);
+      if (before?._id === TestId || after?._id === TestId) return;
+      if (op === "c" && this.callbacks.created && after)
+        await this.callbacks.created({
+          before: null,
+          after: this.mapper(after)
+        });
+      else if (op === "u" && this.callbacks.updated && before && after)
+        await this.callbacks.updated({
+          before: this.mapper(before),
+          after: this.mapper(after),
+          changes: differ.from(differ.diff(before, after))
+        });
+      else if (op === "d" && this.callbacks.deleted && before)
+        await this.callbacks.deleted({
+          before: this.mapper(before),
+          after: null
+        });
+    });
+    Instance.on("start", async () => {
+      if (this.#started) return;
+      this.#started = true;
+      await retry(
+        async () => {
+          const started = await this.configureConnector(topic, {
+            "connector.class": "io.debezium.connector.mongodb.MongoDbConnector",
+            "capture.mode": "change_streams_update_full_with_pre_image",
+            "mongodb.connection.string": config.uri,
+            "collection.include.list": dbColName,
+            "snapshot.mode": "when_needed",
+            "capture.scope": "collection",
+            "capture.target": dbColName,
+            "heartbeat.interval.ms": "60000",
+            "errors.max.retries": "3"
+          });
+          if (started) return { done: true, value: true };
+          await collection.findOneAndUpdate(condition, { $set: { colName } }, { upsert: true });
+          await collection.findOneAndDelete(condition);
+          Instance.get().log.warn(`Waiting for db changes for ${dbColName} to start...`);
+          return { done: false };
+        },
+        6,
+        3e4
+      ).catch((err) => Instance.crash(new EquippedError(`Failed to start db changes`, { dbColName }, err)));
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/db.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  MongoClient,
+  ObjectId
+} from "mongodb";
+import { v as v3 } from "valleyed";
+
+// src/dbs/adapters/mongodb/pipes.ts
+import { v as v2 } from "valleyed";
+var mongoDbConfigPipe = () => v2.meta(
+  v2.object({
+    uri: v2.string()
+  }),
+  { title: "Mongodb Config", $refId: "MongodbConfig" }
+);
+
+// src/dbs/adapters/mongodb/query.ts
+import "mongodb";
+var parseMongodbQueryParams = async (collection, params) => {
+  const query = [];
+  const where = buildWhereQuery(params.where, params.whereType);
+  if (where) query.push(where);
+  const auth = buildWhereQuery(params.auth, params.authType);
+  if (auth) query.push(auth);
+  if (params.search && params.search.fields.length > 0) {
+    const search = params.search.fields.map((field) => ({
+      [field]: {
+        $regex: new RegExp(params.search.value, "i")
+      }
+    }));
+    query.push({ $or: search });
+  }
+  const totalClause = {};
+  if (query.length > 0) totalClause["$and"] = query;
+  const sort = params.sort.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+  const all = params.all ?? false;
+  const limit = params.limit;
+  const page = params.page;
+  const total = await collection.countDocuments(totalClause);
+  const projection = params.select?.length ? Object.fromEntries(params.select.map((k) => [k, 1])) : void 0;
+  let builtQuery = collection.find(totalClause, { projection });
+  if (sort.length) builtQuery = builtQuery.sort(Object.fromEntries(sort));
+  if (!all && limit) {
+    builtQuery = builtQuery.limit(limit);
+    if (page) builtQuery = builtQuery.skip((page - 1) * limit);
+  }
+  const results = await builtQuery.toArray();
+  const start = 1;
+  const last = Math.ceil(total / limit) || 1;
+  const next = page >= last ? null : page + 1;
+  const previous = page <= start ? null : page - 1;
+  return {
+    pages: { start, last, next, previous, current: page },
+    docs: { limit, total, count: results.length },
+    results
+  };
+};
+function isWhereBlock(param) {
+  return Object.values(QueryKeys).includes(param.condition);
+}
+var buildWhereQuery = (params, key = "and" /* and */) => {
+  const where = (Array.isArray(params) ? params : []).map((param) => {
+    if (isWhereBlock(param)) return buildWhereQuery(param.value, param.condition);
+    const { field } = param;
+    const checkedField = field === "id" ? "_id" : field ?? "";
+    const checkedValue = param.value === void 0 ? "" : param.value;
+    return {
+      field: checkedField,
+      value: checkedValue,
+      condition: param.condition,
+      isWhere: true
+    };
+  }).filter((c) => !!c).map((c) => {
+    if (c.isWhere) return { [`${c.field}`]: { [`$${c.condition}`]: c.value } };
+    else return c;
+  });
+  return where.length > 0 ? { [`$${key}`]: where } : null;
+};
+
+// src/dbs/adapters/mongodb/db.ts
+var idKey = "_id";
+var sessionStore = new AsyncLocalStorage(void 0);
+var MongoDb = class extends Db {
+  constructor(mongoConfig, dbConfig) {
+    super(dbConfig);
+    this.mongoConfig = mongoConfig;
+    this.mongoConfig = v3.assert(mongoDbConfigPipe(), mongoConfig);
+    this.client = new MongoClient(mongoConfig.uri, { ignoreUndefined: true });
+    Instance.on("start", async () => {
+      await this.client.connect();
+      const grouped = this.#cols.reduce((acc, cur) => {
+        if (!acc[cur.db]) acc[cur.db] = [];
+        acc[cur.db].push(cur.col);
+        return acc;
+      }, {});
+      const options = {
+        changeStreamPreAndPostImages: { enabled: true }
+      };
+      await Promise.all(
+        Object.entries(grouped).map(async ([dbName, colNames]) => {
+          const db = this.client.db(dbName);
+          const collections = await db.listCollections().toArray();
+          return colNames.map(async (colName) => {
+            const existing = collections.find((collection) => collection.name === colName);
+            if (existing) {
+              if (existing.options?.changeStreamPreAndPostImages?.enabled !== options.changeStreamPreAndPostImages.enabled)
+                await db.command({ collMod: colName, ...options });
+            } else await db.createCollection(colName, options);
+          });
+        })
+      );
+    });
+    Instance.on("close", async () => this.client.close());
+  }
+  client;
+  #cols = [];
+  async session(callback) {
+    if (sessionStore.getStore()) return callback();
+    const session = await this.client.startSession();
+    return session.withTransaction(async () => sessionStore.run(session, callback));
+  }
+  id() {
+    return new ObjectId();
+  }
+  use(config) {
+    const db = this.getScopedDb(config.db);
+    this.#cols.push({ db, col: config.col });
+    return this.#getTable(config, this.client.db(db).collection(config.col));
+  }
+  #getTable(config, collection) {
+    function transform(doc, select) {
+      const docs = Array.isArray(doc) ? doc : [doc];
+      const mapped = docs.map((d) => config.mapper(d, select));
+      return Array.isArray(doc) ? mapped : mapped[0];
+    }
+    function prepInsertValue(value, id, now, skipUpdate) {
+      const base = {
+        [idKey]: id,
+        ...config.options?.skipAudit ? {} : {
+          createdAt: now.getTime(),
+          ...skipUpdate ? {} : { updatedAt: now.getTime() }
+        }
+      };
+      return {
+        ...value,
+        ...base
+      };
+    }
+    function prepUpdateValue(value, now, upsert = false) {
+      return {
+        ...value,
+        $set: {
+          ...value.$set,
+          ...upsert || Object.keys(value).length > 0 && !config.options?.skipAudit ? { updatedAt: now.getTime() } : {}
+        }
+      };
+    }
+    const dbThis = this;
+    const table = {
+      config,
+      extras: { collection },
+      query: async (params) => {
+        const results = await parseMongodbQueryParams(collection, params);
+        return {
+          ...results,
+          results: transform(results.results, params.select)
+        };
+      },
+      findMany: async (filter, options = {}) => {
+        const { select, ...rest } = options;
+        const projection = select?.length ? Object.fromEntries(select.map((k) => [k, 1])) : void 0;
+        const sortArray = Array.isArray(rest.sort) ? rest.sort : rest.sort ? [rest.sort] : [];
+        const sort = sortArray.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+        const docs = await collection.find(filter, {
+          session: sessionStore.getStore(),
+          limit: rest.limit,
+          sort,
+          projection
+        }).toArray();
+        return transform(docs, select);
+      },
+      findOne: async (filter, options = {}) => {
+        const result = await table.findMany(filter, { ...options, limit: 1 });
+        return result.at(0) ?? null;
+      },
+      findById: async (id, options = {}) => {
+        const result = await table.findOne({ [idKey]: id }, options);
+        return result;
+      },
+      insertMany: async (values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const payload = values.map((value, i) => prepInsertValue(value, options.makeId?.(i) ?? new ObjectId().toString(), now));
+        await collection.insertMany(payload, { session: sessionStore.getStore() });
+        const insertedData = await Promise.all(payload.map(async (data) => await table.findById(data[idKey])));
+        return insertedData.filter((value) => !!value);
+      },
+      insertOne: async (values, options = {}) => {
+        const result = await table.insertMany([values], options);
+        return result[0];
+      },
+      updateMany: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const session = sessionStore.getStore();
+        const data = await collection.find(filter, { session, projection: { [idKey]: 1 } }).toArray();
+        const ids = data.map((doc) => doc[idKey]);
+        const filterUpd = { [idKey]: { $in: ids } };
+        await collection.updateMany(filterUpd, prepUpdateValue(values, now), { session });
+        return table.findMany(filterUpd);
+      },
+      updateOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(filter, prepUpdateValue(values, now), {
+          returnDocument: "after",
+          session: sessionStore.getStore()
+        });
+        return doc ? transform(doc, void 0) : null;
+      },
+      updateById: async (id, values, options = {}) => {
+        const result = await table.updateOne({ [idKey]: id }, values, options);
+        return result;
+      },
+      upsertOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(
+          filter,
+          {
+            ...prepUpdateValue("update" in values ? values.update : {}, now, true),
+            // @ts-expect-error fighting ts
+            $setOnInsert: prepInsertValue(values.insert, options.makeId?.() ?? new ObjectId().toString(), now, true)
+          },
+          { returnDocument: "after", session: sessionStore.getStore(), upsert: true }
+        );
+        return transform(doc, void 0);
+      },
+      deleteMany: async (filter, options = {}) => {
+        const docs = await table.findMany(filter, options);
+        await collection.deleteMany(filter, { session: sessionStore.getStore() });
+        return docs;
+      },
+      deleteOne: async (filter) => {
+        const doc = await collection.findOneAndDelete(filter, { session: sessionStore.getStore() });
+        return doc ? transform(doc, void 0) : null;
+      },
+      deleteById: async (id) => {
+        const result = await table.deleteOne({ [idKey]: id });
+        return result;
+      },
+      bulkWrite: async (operations, options = {}) => {
+        if (!operations.length) return;
+        const bulk = collection.initializeUnorderedBulkOp({ session: sessionStore.getStore() });
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        operations.forEach((operation, i) => {
+          switch (operation.op) {
+            case "insert":
+              bulk.insert(prepInsertValue(operation.value, operation.makeId?.(i) ?? new ObjectId().toString(), now));
+              break;
+            case "delete":
+              bulk.find(operation.filter).delete();
+              break;
+            case "update":
+              bulk.find(operation.filter).update(prepUpdateValue(operation.value, now));
+              break;
+            case "upsert":
+              bulk.find(operation.filter).upsert().update({
+                ...prepUpdateValue("update" in operation ? operation.update : {}, now, true),
+                $setOnInsert: prepInsertValue(
+                  operation.insert,
+                  operation.makeId?.(i) ?? new ObjectId().toString(),
+                  now,
+                  true
+                )
+              });
+              break;
+            default:
+              throw new EquippedError(`Unknown bulkWrite operation`, { operation });
+          }
+        });
+        await bulk.execute({ session: sessionStore.getStore() });
+      },
+      watch(callbacks) {
+        if (!dbThis.config.changes)
+          Instance.crash(new EquippedError("Db changes are not enabled in the configuration.", { config }));
+        return new MongoDbChange(
+          dbThis.mongoConfig,
+          dbThis.config.changes,
+          collection,
+          callbacks,
+          (m) => config.mapper(m)
+        );
+      }
+    };
+    return table;
+  }
+};
+export {
+  MongoDb,
+  MongoDbChange,
+  mongoDbConfigPipe
+};

package/dist/types/dbs/index.d.ts

@@ -1,18 +1,20 @@
-import { M as Model, E as Entity, D as DbChange, a as MongoDbConfig, b as DbChangeConfig, c as DbChangeCallbacks } from '../core-BrkNSwvc.js';
-export { B as BulkWriteOperation, g as Conditions, e as Config, C as CreateInput, f as DbConfig, d as EntityInput, I as IdType, Q as QueryKeys, i as QueryParams, j as QueryParamsInput, n as QueryResults, l as QueryWhere, m as QueryWhereBlock, k as QueryWhereClause, T as Table, U as UpdateInput, o as mongoDbConfigPipe, q as queryParamsPipe, h as queryResultsPipe, w as wrapQueryParams } from '../core-BrkNSwvc.js';
-export { D as Db, T as TableOptions } from '../db-C8YY1yTO.js';
-import { Collection } from 'mongodb';
+import { I as IdType, c as DbConfig, M as Model, E as Entity, C as Config, T as Table } from '../core-tNlIMH9Y.js';
+export { B as BulkWriteOperation, g as Conditions, e as CreateInput, b as DbChangeCallbacks, a as DbChangeConfig, d as EntityInput, Q as QueryKeys, j as QueryParams, i as QueryParamsBase, k as QueryParamsInput, o as QueryResults, m as QueryWhere, n as QueryWhereBlock, l as QueryWhereClause, S as Select, U as UpdateInput, f as dbChangeConfigPipe, q as queryParamsPipe, h as queryResultsPipe, w as wrapQueryParams } from '../core-tNlIMH9Y.js';
 export { Filter } from 'mongodb';
-export { M as MongoDb } from '../db-Dj1SGto0.js';
 import 'valleyed';
-import '../kafka-Cf-TUJgv.js';
+import '../events/adapters/kafka/index.js';
 import '../overrides-6Hxg764S.js';
+import '../events/index.js';
 
-declare class MongoDbChange<Model extends Model<{
-    _id: string;
-}>, Entity extends Entity> extends DbChange<Model, Entity> {
-    #private;
-    constructor(config: MongoDbConfig, change: DbChangeConfig, collection: Collection<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+type TableOptions = {
+    skipAudit?: boolean;
+};
+declare abstract class Db<IdKey extends IdType> {
+    protected config: DbConfig;
+    constructor(config: DbConfig);
+    protected getScopedDb(db: string): string;
+    abstract use<Model extends Model<IdKey>, Entity extends Entity>(config: Config<Model, Entity>): Table<IdKey, Model, Entity>;
+    abstract session<T>(callback: () => Promise<T>): Promise<T>;
 }
 
-export { DbChangeCallbacks, DbChangeConfig, Entity, Model, MongoDbChange, MongoDbConfig };
+export { Config, Db, DbConfig, Entity, IdType, Model, Table, type TableOptions };

package/dist/types/dbs/index.js

@@ -1,6 +1,22 @@
-export * from "./base/core.js";
-export * from "./base/db.js";
-export * from "./base/types.js";
-export * from "./mongo/changes.js";
-export * from "./mongo/db.js";
-export * from "./pipes.js";
+import {
+  Conditions,
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+} from "../chunk-JZ2JTENY.js";
+import "../chunk-IAHTILKJ.js";
+import "../chunk-32DMHN3G.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Conditions,
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+};

package/dist/types/equippedError-Cmo60Kn-.d.ts

@@ -0,0 +1,8 @@
+declare class EquippedError extends Error {
+    readonly message: string;
+    readonly context: Record<string, unknown>;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
+}
+
+export { EquippedError as E };

package/dist/types/errors/index.d.ts

@@ -1,6 +1,6 @@
-import { R as RequestError } from '../requestError-C2PNWUrt.js';
-export { E as EquippedError } from '../requestError-C2PNWUrt.js';
-export { V as ValidationError } from '../validationError-Bw8OYv5s.js';
+export { E as EquippedError } from '../equippedError-Cmo60Kn-.js';
+import { b as RequestError } from '../requestError-DdaL8hc3.js';
+export { V as ValidationError } from '../validationError-oigtHqBi.js';
 import 'valleyed';
 import '../types/index.js';
 import '../overrides-6Hxg764S.js';

package/dist/types/errors/index.js

@@ -1,8 +1,22 @@
-export * from "./equippedError.js";
-export * from "./requestError.js";
-export * from "./types/badRequestError.js";
-export * from "./types/notAuthenticatedError.js";
-export * from "./types/notAuthorizedError.js";
-export * from "./types/notFoundError.js";
-export * from "./types/tokenExpired.js";
-export * from "./types/validationError.js";
+import {
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RequestError,
+  TokenExpired,
+  ValidationError
+} from "../chunk-32DMHN3G.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RequestError,
+  TokenExpired,
+  ValidationError
+};

package/dist/types/events/adapters/kafka/index.d.ts

@@ -0,0 +1,83 @@
+import * as valleyed from 'valleyed';
+import { E as Events } from '../../../overrides-6Hxg764S.js';
+import { EventBus, StreamOptions, Stream } from '../../index.js';
+
+declare const kafkaConfigPipe: () => valleyed.Pipe<{
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}, {
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}>;
+declare const KafkaEventBus_base: (abstract new (validated: {
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}) => EventBus & {
+    readonly config: {
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    };
+}) & {
+    readonly Config: {
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        brokers: string[];
+        ssl?: boolean | undefined;
+        sasl?: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId?: string | undefined;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class KafkaEventBus extends KafkaEventBus_base {
+    #private;
+    protected constructor(config: typeof KafkaEventBus.Config);
+    stream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): Stream<Event['data']>;
+}
+
+export { KafkaEventBus, kafkaConfigPipe };

package/dist/types/events/adapters/kafka/index.js

@@ -0,0 +1,11 @@
+import {
+  KafkaEventBus,
+  kafkaConfigPipe
+} from "../../../chunk-IAHTILKJ.js";
+import "../../../chunk-32DMHN3G.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+export {
+  KafkaEventBus,
+  kafkaConfigPipe
+};

package/dist/types/events/adapters/rabbitmq/index.d.ts

@@ -0,0 +1,41 @@
+import * as valleyed from 'valleyed';
+import { E as Events } from '../../../overrides-6Hxg764S.js';
+import { EventBus, StreamOptions, Stream } from '../../index.js';
+
+declare const rabbitmqConfigPipe: () => valleyed.Pipe<{
+    uri: string;
+    eventColumnName: string;
+}, {
+    uri: string;
+    eventColumnName: string;
+}>;
+declare const RabbitMQEventBus_base: (abstract new (validated: {
+    uri: string;
+    eventColumnName: string;
+}) => EventBus & {
+    readonly config: {
+        uri: string;
+        eventColumnName: string;
+    };
+}) & {
+    readonly Config: {
+        uri: string;
+        eventColumnName: string;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        uri: string;
+        eventColumnName: string;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        uri: string;
+        eventColumnName: string;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class RabbitMQEventBus extends RabbitMQEventBus_base {
+    #private;
+    protected constructor(config: typeof RabbitMQEventBus.Config);
+    stream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): Stream<Event['data']>;
+}
+
+export { RabbitMQEventBus, rabbitmqConfigPipe };