@eventcatalog/sdk 1.1.4 → 1.2.1

package/README.md

@@ -68,6 +68,14 @@ Thank you to our project sponsors.
 
 <hr />
 
+<div align="center">
+  <img alt="oso" src="./images/sponsors/oso-logo-green.png" width="40%" />
+  <p style="margin: 0; padding: 0;">Delivering Apache Kafka professional services to your business</p>
+  <a href="https://oso.sh/?utm_source=eventcatalog&utm_medium=web&utm_campaign=sponsorship" target="_blank" >Learn more</a>
+</div>
+
+<hr />
+
 _Sponsors help make EventCatalog sustainable, want to help the project? Get in touch! Or [visit our sponsor page](https://www.eventcatalog.dev/support)._
 
 # Enterprise support

package/dist/channels.d.mts

@@ -0,0 +1,167 @@
+import { Channel } from './types.d.mjs';
+
+/**
+ * Returns a channel from EventCatalog.
+ *
+ * You can optionally specify a version to get a specific version of the channel
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { getChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Gets the latest version of the channel
+ * const channel = await getChannel('InventoryChannel');
+ *
+ * // Gets a version of the channel
+ * const channel = await getChannel('InventoryChannel', '0.0.1');
+ * ```
+ */
+declare const getChannel: (directory: string) => (id: string, version?: string) => Promise<Channel>;
+/**
+ * Write a channel to EventCatalog.
+ *
+ * You can optionally override the path of the channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { writeChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Write a channel to the catalog
+ * // channel would be written to channels/inventory.{env}.events
+ * await writeChannel({
+ *   id: 'inventory.{env}.events',
+ *   name: 'Inventory channel',
+ *   version: '0.0.1',
+ *   summary: 'This is a summary',
+ *   markdown: '# Hello world',
+ *   address: inventory.{env}.events,
+ * protocols: ['http'],
+ * });
+ *
+ * // Write a channel to the catalog but override the path
+ * // channel would be written to channels/Inventory/InventoryChannel
+ * await writeChannel({
+ *    id: 'InventoryChannel',
+ *    name: 'Update Inventory',
+ *    version: '0.0.1',
+ *    summary: 'This is a summary',
+ *    markdown: '# Hello world',
+ *    address: inventory.{env}.events,
+ *    protocols: ['http'],
+ * }, { path: "/channels/Inventory/InventoryChannel"});
+ * ```
+ */
+declare const writeChannel: (directory: string) => (channel: Channel, options?: {
+    path: string;
+}) => Promise<void>;
+/**
+ * Delete a channel at it's given path.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { rmChannel } = utils('/path/to/eventcatalog');
+ *
+ * // removes a channel at the given path (channels dir is appended to the given path)
+ * // Removes the channel at channels/InventoryChannel
+ * await rmChannel('/InventoryChannel');
+ * ```
+ */
+declare const rmChannel: (directory: string) => (path: string) => Promise<void>;
+/**
+ * Delete a channel by it's id.
+ *
+ * Optionally specify a version to delete a specific version of the channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { rmChannelById } = utils('/path/to/eventcatalog');
+ *
+ * // deletes the latest InventoryChannel channel
+ * await rmChannelById('inventory.{env}.events');
+ *
+ * // deletes a specific version of the InventoryChannel channel
+ * await rmChannelById('inventory.{env}.events', '0.0.1');
+ * ```
+ */
+declare const rmChannelById: (directory: string) => (id: string, version?: string) => Promise<void>;
+/**
+ * Version a channel by it's id.
+ *
+ * Takes the latest channel and moves it to a versioned directory.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { versionChannel } = utils('/path/to/eventcatalog');
+ *
+ * // moves the latest inventory.{env}.events channel to a versioned directory
+ * // the version within that channel is used as the version number.
+ * await versionChannel('inventory.{env}.events');
+ *
+ * ```
+ */
+declare const versionChannel: (directory: string) => (id: string) => Promise<void>;
+/**
+ * Check to see if the catalog has a version for the given channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { channelHasVersion } = utils('/path/to/eventcatalog');
+ *
+ * // returns true if version is found for the given event and version (supports semver)
+ * await channelHasVersion('inventory.{env}.events', '0.0.1');
+ * await channelHasVersion('inventory.{env}.events', 'latest');
+ * await channelHasVersion('inventory.{env}.events', '0.0.x');*
+ *
+ * ```
+ */
+declare const channelHasVersion: (directory: string) => (id: string, version: string) => Promise<boolean>;
+/**
+ * Add an event/command/query to a channel by it's id.
+ *
+ * Optionally specify a version to add the message to a specific version of the service.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * // Adds an event to the service or command to the service
+ * const { addEventToChannel, addCommandToChannel, addQueryToChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Adds a new event (InventoryUpdatedEvent) that the InventoryService will send
+ * await addEventToChannel('InventoryService', 'sends', { event: 'InventoryUpdatedEvent', version: '2.0.0' });
+ * * // Adds a new event (OrderComplete) that the InventoryService will receive
+ * await addEventToChannel('InventoryService', 'receives', { event: 'OrderComplete', version: '1.0.0' });
+ *
+ * // Adds a new command (UpdateInventoryCommand) that the InventoryService will send
+ * await addCommandToChannel('InventoryService', 'sends', { command: 'UpdateInventoryCommand', version: '2.0.0' });
+ * // Adds a new command (VerifyInventory) that the InventoryService will receive
+ * await addCommandToChannel('InventoryService', 'receives', { command: 'VerifyInventory', version: '1.0.0' });
+ *
+ * // Adds a new query (GetInventoryQuery) that the InventoryService will send
+ * await addQueryToChannel('InventoryService', 'sends', { query: 'GetInventoryQuery', version: '2.0.0' });
+ * // Adds a new query (GetOrder) that the InventoryService will receive
+ * await addQueryToChannel('InventoryService', 'receives', { query: 'GetOrder', version: '1.0.0' });
+ *
+ * ```
+ */
+declare const addMessageToChannel: (directory: string, collection: string) => (id: string, _message: {
+    id: string;
+    version: string;
+    parameters?: {
+        [key: string]: string;
+    };
+}, version?: string) => Promise<void>;
+
+export { addMessageToChannel, channelHasVersion, getChannel, rmChannel, rmChannelById, versionChannel, writeChannel };

package/dist/channels.d.ts

@@ -0,0 +1,167 @@
+import { Channel } from './types.d.js';
+
+/**
+ * Returns a channel from EventCatalog.
+ *
+ * You can optionally specify a version to get a specific version of the channel
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { getChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Gets the latest version of the channel
+ * const channel = await getChannel('InventoryChannel');
+ *
+ * // Gets a version of the channel
+ * const channel = await getChannel('InventoryChannel', '0.0.1');
+ * ```
+ */
+declare const getChannel: (directory: string) => (id: string, version?: string) => Promise<Channel>;
+/**
+ * Write a channel to EventCatalog.
+ *
+ * You can optionally override the path of the channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { writeChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Write a channel to the catalog
+ * // channel would be written to channels/inventory.{env}.events
+ * await writeChannel({
+ *   id: 'inventory.{env}.events',
+ *   name: 'Inventory channel',
+ *   version: '0.0.1',
+ *   summary: 'This is a summary',
+ *   markdown: '# Hello world',
+ *   address: inventory.{env}.events,
+ * protocols: ['http'],
+ * });
+ *
+ * // Write a channel to the catalog but override the path
+ * // channel would be written to channels/Inventory/InventoryChannel
+ * await writeChannel({
+ *    id: 'InventoryChannel',
+ *    name: 'Update Inventory',
+ *    version: '0.0.1',
+ *    summary: 'This is a summary',
+ *    markdown: '# Hello world',
+ *    address: inventory.{env}.events,
+ *    protocols: ['http'],
+ * }, { path: "/channels/Inventory/InventoryChannel"});
+ * ```
+ */
+declare const writeChannel: (directory: string) => (channel: Channel, options?: {
+    path: string;
+}) => Promise<void>;
+/**
+ * Delete a channel at it's given path.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { rmChannel } = utils('/path/to/eventcatalog');
+ *
+ * // removes a channel at the given path (channels dir is appended to the given path)
+ * // Removes the channel at channels/InventoryChannel
+ * await rmChannel('/InventoryChannel');
+ * ```
+ */
+declare const rmChannel: (directory: string) => (path: string) => Promise<void>;
+/**
+ * Delete a channel by it's id.
+ *
+ * Optionally specify a version to delete a specific version of the channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { rmChannelById } = utils('/path/to/eventcatalog');
+ *
+ * // deletes the latest InventoryChannel channel
+ * await rmChannelById('inventory.{env}.events');
+ *
+ * // deletes a specific version of the InventoryChannel channel
+ * await rmChannelById('inventory.{env}.events', '0.0.1');
+ * ```
+ */
+declare const rmChannelById: (directory: string) => (id: string, version?: string) => Promise<void>;
+/**
+ * Version a channel by it's id.
+ *
+ * Takes the latest channel and moves it to a versioned directory.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { versionChannel } = utils('/path/to/eventcatalog');
+ *
+ * // moves the latest inventory.{env}.events channel to a versioned directory
+ * // the version within that channel is used as the version number.
+ * await versionChannel('inventory.{env}.events');
+ *
+ * ```
+ */
+declare const versionChannel: (directory: string) => (id: string) => Promise<void>;
+/**
+ * Check to see if the catalog has a version for the given channel.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * const { channelHasVersion } = utils('/path/to/eventcatalog');
+ *
+ * // returns true if version is found for the given event and version (supports semver)
+ * await channelHasVersion('inventory.{env}.events', '0.0.1');
+ * await channelHasVersion('inventory.{env}.events', 'latest');
+ * await channelHasVersion('inventory.{env}.events', '0.0.x');*
+ *
+ * ```
+ */
+declare const channelHasVersion: (directory: string) => (id: string, version: string) => Promise<boolean>;
+/**
+ * Add an event/command/query to a channel by it's id.
+ *
+ * Optionally specify a version to add the message to a specific version of the service.
+ *
+ * @example
+ * ```ts
+ * import utils from '@eventcatalog/utils';
+ *
+ * // Adds an event to the service or command to the service
+ * const { addEventToChannel, addCommandToChannel, addQueryToChannel } = utils('/path/to/eventcatalog');
+ *
+ * // Adds a new event (InventoryUpdatedEvent) that the InventoryService will send
+ * await addEventToChannel('InventoryService', 'sends', { event: 'InventoryUpdatedEvent', version: '2.0.0' });
+ * * // Adds a new event (OrderComplete) that the InventoryService will receive
+ * await addEventToChannel('InventoryService', 'receives', { event: 'OrderComplete', version: '1.0.0' });
+ *
+ * // Adds a new command (UpdateInventoryCommand) that the InventoryService will send
+ * await addCommandToChannel('InventoryService', 'sends', { command: 'UpdateInventoryCommand', version: '2.0.0' });
+ * // Adds a new command (VerifyInventory) that the InventoryService will receive
+ * await addCommandToChannel('InventoryService', 'receives', { command: 'VerifyInventory', version: '1.0.0' });
+ *
+ * // Adds a new query (GetInventoryQuery) that the InventoryService will send
+ * await addQueryToChannel('InventoryService', 'sends', { query: 'GetInventoryQuery', version: '2.0.0' });
+ * // Adds a new query (GetOrder) that the InventoryService will receive
+ * await addQueryToChannel('InventoryService', 'receives', { query: 'GetOrder', version: '1.0.0' });
+ *
+ * ```
+ */
+declare const addMessageToChannel: (directory: string, collection: string) => (id: string, _message: {
+    id: string;
+    version: string;
+    parameters?: {
+        [key: string]: string;
+    };
+}, version?: string) => Promise<void>;
+
+export { addMessageToChannel, channelHasVersion, getChannel, rmChannel, rmChannelById, versionChannel, writeChannel };

package/dist/channels.js

@@ -0,0 +1,259 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/channels.ts
+var channels_exports = {};
+__export(channels_exports, {
+  addMessageToChannel: () => addMessageToChannel,
+  channelHasVersion: () => channelHasVersion,
+  getChannel: () => getChannel,
+  rmChannel: () => rmChannel,
+  rmChannelById: () => rmChannelById,
+  versionChannel: () => versionChannel,
+  writeChannel: () => writeChannel
+});
+module.exports = __toCommonJS(channels_exports);
+var import_promises6 = __toESM(require("fs/promises"));
+var import_node_path5 = require("path");
+
+// src/internal/resources.ts
+var import_path = require("path");
+
+// src/internal/utils.ts
+var import_glob = require("glob");
+var import_promises = __toESM(require("fs/promises"));
+var import_fs_extra = require("fs-extra");
+var import_node_path = require("path");
+var import_gray_matter = __toESM(require("gray-matter"));
+var import_semver = require("semver");
+var versionExists = async (catalogDir, id, version) => {
+  const files = await getFiles(`${catalogDir}/**/index.md`);
+  const matchedFiles = await searchFilesForId(files, id, version) || [];
+  return matchedFiles.length > 0;
+};
+var findFileById = async (catalogDir, id, version) => {
+  const files = await getFiles(`${catalogDir}/**/index.md`);
+  const matchedFiles = await searchFilesForId(files, id) || [];
+  const latestVersion = matchedFiles.find((path) => !path.includes("versioned"));
+  if (!version) {
+    return latestVersion;
+  }
+  const parsedFiles = matchedFiles.map((path) => {
+    const { data } = import_gray_matter.default.read(path);
+    return { ...data, path };
+  });
+  const semverRange = (0, import_semver.validRange)(version);
+  if (semverRange && (0, import_semver.valid)(version)) {
+    const match2 = parsedFiles.filter((c) => (0, import_semver.satisfies)(c.version, semverRange));
+    return match2.length > 0 ? match2[0].path : void 0;
+  }
+  const sorted = parsedFiles.sort((a, b) => {
+    return a.version.localeCompare(b.version);
+  });
+  const match = sorted.length > 0 ? [sorted[sorted.length - 1]] : [];
+  if (match.length > 0) {
+    return match[0].path;
+  }
+};
+var getFiles = async (pattern) => {
+  try {
+    const files = await (0, import_glob.glob)(pattern, { ignore: "node_modules/**" });
+    return files;
+  } catch (error) {
+    throw new Error(`Error finding files: ${error}`);
+  }
+};
+var searchFilesForId = async (files, id, version) => {
+  const idRegex = new RegExp(`^id:\\s*(['"]|>-)?\\s*${id}['"]?\\s*$`, "m");
+  const versionRegex = new RegExp(`^version:\\s*['"]?${version}['"]?\\s*$`, "m");
+  const matches = await Promise.all(
+    files.map(async (file) => {
+      const content = await import_promises.default.readFile(file, "utf-8");
+      const hasIdMatch = content.match(idRegex);
+      if (version && !content.match(versionRegex)) {
+        return void 0;
+      }
+      if (hasIdMatch) {
+        return file;
+      }
+    })
+  );
+  return matches.filter(Boolean).filter((file) => file !== void 0);
+};
+var copyDir = async (catalogDir, source, target, filter) => {
+  const tmpDirectory = (0, import_node_path.join)(catalogDir, "tmp");
+  await import_promises.default.mkdir(tmpDirectory, { recursive: true });
+  await (0, import_fs_extra.copy)(source, tmpDirectory, {
+    overwrite: true,
+    filter
+  });
+  await (0, import_fs_extra.copy)(tmpDirectory, target, {
+    overwrite: true,
+    filter
+  });
+  await import_promises.default.rm(tmpDirectory, { recursive: true });
+};
+
+// src/internal/resources.ts
+var import_gray_matter2 = __toESM(require("gray-matter"));
+var import_promises2 = __toESM(require("fs/promises"));
+var versionResource = async (catalogDir, id) => {
+  const files = await getFiles(`${catalogDir}/**/index.md`);
+  const matchedFiles = await searchFilesForId(files, id);
+  if (matchedFiles.length === 0) {
+    throw new Error(`No event found with id: ${id}`);
+  }
+  const file = matchedFiles[0];
+  const sourceDirectory = (0, import_path.dirname)(file);
+  const { data: { version = "0.0.1" } = {} } = import_gray_matter2.default.read(file);
+  const targetDirectory = getVersionedDirectory(sourceDirectory, version);
+  await import_promises2.default.mkdir(targetDirectory, { recursive: true });
+  await copyDir(catalogDir, sourceDirectory, targetDirectory, (src) => {
+    return !src.includes("versioned");
+  });
+  await import_promises2.default.readdir(sourceDirectory).then(async (resourceFiles) => {
+    await Promise.all(
+      resourceFiles.map(async (file2) => {
+        if (file2 !== "versioned") {
+          await import_promises2.default.rm((0, import_path.join)(sourceDirectory, file2), { recursive: true });
+        }
+      })
+    );
+  });
+};
+var writeResource = async (catalogDir, resource, options = { path: "", type: "" }) => {
+  const path = options.path || `/${resource.id}`;
+  const exists = await versionExists(catalogDir, resource.id, resource.version);
+  if (exists) {
+    throw new Error(`Failed to write ${resource.id} (${options.type}) as the version ${resource.version} already exists`);
+  }
+  const { markdown, ...frontmatter } = resource;
+  const document = import_gray_matter2.default.stringify(markdown.trim(), frontmatter);
+  await import_promises2.default.mkdir((0, import_path.join)(catalogDir, path), { recursive: true });
+  await import_promises2.default.writeFile((0, import_path.join)(catalogDir, path, "index.md"), document);
+};
+var getResource = async (catalogDir, id, version, options) => {
+  const file = await findFileById(catalogDir, id, version);
+  if (!file) return;
+  const { data, content } = import_gray_matter2.default.read(file);
+  return {
+    ...data,
+    markdown: content.trim()
+  };
+};
+var rmResourceById = async (catalogDir, id, version, options) => {
+  const files = await getFiles(`${catalogDir}/**/index.md`);
+  const matchedFiles = await searchFilesForId(files, id, version);
+  if (matchedFiles.length === 0) {
+    throw new Error(`No ${options?.type || "resource"} found with id: ${id}`);
+  }
+  await Promise.all(matchedFiles.map((file) => import_promises2.default.rm(file)));
+};
+var getVersionedDirectory = (sourceDirectory, version) => {
+  return (0, import_path.join)(sourceDirectory, "versioned", version);
+};
+
+// src/events.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path2 = require("path");
+var getEvent = (directory) => async (id, version) => getResource(directory, id, version, { type: "event" });
+var writeEvent = (directory) => async (event, options = { path: "" }) => writeResource(directory, { ...event }, { ...options, type: "event" });
+var rmEventById = (directory) => async (id, version) => {
+  await rmResourceById(directory, id, version, { type: "event" });
+};
+
+// src/commands.ts
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path3 = require("path");
+var getCommand = (directory) => async (id, version) => getResource(directory, id, version, { type: "command" });
+var writeCommand = (directory) => async (command, options = { path: "" }) => writeResource(directory, { ...command }, { ...options, type: "command" });
+var rmCommandById = (directory) => async (id, version) => rmResourceById(directory, id, version, { type: "command" });
+
+// src/queries.ts
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path4 = require("path");
+var getQuery = (directory) => async (id, version) => getResource(directory, id, version, { type: "query" });
+var writeQuery = (directory) => async (query, options = { path: "" }) => writeResource(directory, { ...query }, { ...options, type: "query" });
+var rmQueryById = (directory) => async (id, version) => {
+  await rmResourceById(directory, id, version, { type: "query" });
+};
+
+// src/channels.ts
+var getChannel = (directory) => async (id, version) => getResource(directory, id, version, { type: "channel" });
+var writeChannel = (directory) => async (channel, options = { path: "" }) => writeResource(directory, { ...channel }, { ...options, type: "channel" });
+var rmChannel = (directory) => async (path) => {
+  await import_promises6.default.rm((0, import_node_path5.join)(directory, path), { recursive: true });
+};
+var rmChannelById = (directory) => async (id, version) => rmResourceById(directory, id, version, { type: "channel" });
+var versionChannel = (directory) => async (id) => versionResource(directory, id);
+var channelHasVersion = (directory) => async (id, version) => {
+  const file = await findFileById(directory, id, version);
+  return !!file;
+};
+var addMessageToChannel = (directory, collection) => async (id, _message, version) => {
+  let channel = await getChannel(directory)(id, version);
+  const functions = {
+    events: {
+      getMessage: getEvent,
+      rmMessageById: rmEventById,
+      writeMessage: writeEvent
+    },
+    commands: {
+      getMessage: getCommand,
+      rmMessageById: rmCommandById,
+      writeMessage: writeCommand
+    },
+    queries: {
+      getMessage: getQuery,
+      rmMessageById: rmQueryById,
+      writeMessage: writeQuery
+    }
+  };
+  const { getMessage, rmMessageById, writeMessage } = functions[collection];
+  const message = await getMessage(directory)(_message.id, _message.version);
+  if (!message) throw new Error(`Message ${_message.id} with version ${_message.version} not found`);
+  if (message.channels === void 0) {
+    message.channels = [];
+  }
+  const channelInfo = { id, version: channel.version, ..._message.parameters && { parameters: _message.parameters } };
+  message.channels.push(channelInfo);
+  await rmMessageById(directory)(_message.id, _message.version);
+  await writeMessage(directory)(message);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addMessageToChannel,
+  channelHasVersion,
+  getChannel,
+  rmChannel,
+  rmChannelById,
+  versionChannel,
+  writeChannel
+});
+//# sourceMappingURL=channels.js.map