@amqp-contract/asyncapi 0.1.4 → 0.2.1

package/dist/index.d.mts

@@ -1,136 +1,143 @@
+import { ConditionalSchemaConverter } from "@orpc/openapi";
+import { AsyncAPIObject } from "@asyncapi/parser/esm/spec-types/v3";
 import { ContractDefinition } from "@amqp-contract/contract";
-import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/generator.d.ts
-/**
- * AsyncAPI 3.0.0 Specification
- */
-interface AsyncAPIDocument {
-  asyncapi: "3.0.0";
-  info: AsyncAPIInfo;
-  servers?: Record<string, AsyncAPIServer>;
-  channels?: Record<string, AsyncAPIChannel>;
-  operations?: Record<string, AsyncAPIOperation>;
-  components?: AsyncAPIComponents;
-}
-interface AsyncAPIInfo {
-  title: string;
-  version: string;
-  description?: string;
-  termsOfService?: string;
-  contact?: {
-    name?: string;
-    url?: string;
-    email?: string;
-  };
-  license?: {
-    name: string;
-    url?: string;
-  };
-}
-interface AsyncAPIServer {
-  host: string;
-  protocol: string;
-  description?: string;
-  variables?: Record<string, {
-    default: string;
-    description?: string;
-  }>;
-}
-interface AsyncAPIChannel {
-  address: string;
-  messages?: Record<string, AsyncAPIMessageRef>;
-  description?: string;
-  bindings?: {
-    amqp?: {
-      is: "queue" | "routingKey";
-      queue?: {
-        name: string;
-        durable?: boolean;
-        exclusive?: boolean;
-        autoDelete?: boolean;
-      };
-      exchange?: {
-        name: string;
-        type: "topic" | "direct" | "fanout" | "headers";
-        durable?: boolean;
-        autoDelete?: boolean;
-      };
-    };
-  };
-}
-interface AsyncAPIOperation {
-  action: "send" | "receive";
-  channel: AsyncAPIRef;
-  messages?: AsyncAPIMessageRef[];
-  description?: string;
-}
-interface AsyncAPIMessageRef {
-  $ref?: string;
-  payload?: AsyncAPISchema;
-  contentType?: string;
-  name?: string;
-  title?: string;
-  summary?: string;
-  description?: string;
-}
-interface AsyncAPISchema {
-  type?: string;
-  properties?: Record<string, AsyncAPISchema>;
-  required?: string[];
-  items?: AsyncAPISchema;
-  $ref?: string;
-  description?: string;
-  format?: string;
-  minimum?: number;
-  maximum?: number;
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  enum?: unknown[];
-}
-interface AsyncAPIRef {
-  $ref: string;
-}
-interface AsyncAPIComponents {
-  messages?: Record<string, AsyncAPIMessageRef>;
-  schemas?: Record<string, AsyncAPISchema>;
-}
+//#region src/index.d.ts
+
 /**
- * Options for generating AsyncAPI specification
+ * Options for configuring the AsyncAPI generator.
+ *
+ * @example
+ * ```typescript
+ * import { AsyncAPIGenerator } from '@amqp-contract/asyncapi';
+ * import { zodToJsonSchema } from '@orpc/zod';
+ *
+ * const generator = new AsyncAPIGenerator({
+ *   schemaConverters: [zodToJsonSchema]
+ * });
+ * ```
  */
-interface GenerateAsyncAPIOptions {
-  info: Omit<AsyncAPIInfo, "title" | "version"> & {
-    title?: string;
-    version?: string;
-  };
-  servers?: Record<string, AsyncAPIServer>;
+interface AsyncAPIGeneratorOptions {
+  /**
+   * Schema converters for transforming validation schemas to JSON Schema.
+   * Supports Zod, Valibot, ArkType, and other Standard Schema v1 compatible libraries.
+   */
+  schemaConverters?: ConditionalSchemaConverter[];
 }
 /**
- * Generate AsyncAPI 3.0.0 specification from AMQP contract
+ * Options for generating an AsyncAPI document.
+ * These correspond to the top-level AsyncAPI document fields.
  */
-declare function generateAsyncAPI(contract: ContractDefinition, options: GenerateAsyncAPIOptions): AsyncAPIDocument;
-//#endregion
-//#region src/schema-converter.d.ts
+type AsyncAPIGeneratorGenerateOptions = Pick<AsyncAPIObject, "id" | "info" | "servers">;
 /**
- * Convert a Standard Schema to JSON Schema (AsyncAPI format)
- *
- * This is a basic converter that returns a generic object schema.
- * Users should provide their own schema-to-JSON-Schema converter function
- * specific to their schema library.
+ * Generator for creating AsyncAPI 3.0 documentation from AMQP contracts.
  *
- * For Zod users, import and use zodToJsonSchema from @amqp-contract/zod
+ * This class converts contract definitions into AsyncAPI 3.0 specification documents,
+ * which can be used for API documentation, code generation, and tooling integration.
  *
  * @example
- * ```ts
- * import { zodToJsonSchema } from '@amqp-contract/zod';
- * import { generateAsyncAPI } from '@amqp-contract/asyncapi';
+ * ```typescript
+ * import { AsyncAPIGenerator } from '@amqp-contract/asyncapi';
+ * import { zodToJsonSchema } from '@orpc/zod';
+ * import { z } from 'zod';
+ *
+ * const contract = defineContract({
+ *   exchanges: {
+ *     orders: defineExchange('orders', 'topic', { durable: true })
+ *   },
+ *   publishers: {
+ *     orderCreated: definePublisher('orders', z.object({
+ *       orderId: z.string(),
+ *       amount: z.number()
+ *     }), {
+ *       routingKey: 'order.created'
+ *     })
+ *   }
+ * });
  *
- * // Use zodToJsonSchema for converting Zod schemas
- * const jsonSchema = zodToJsonSchema(zodSchema);
+ * const generator = new AsyncAPIGenerator({
+ *   schemaConverters: [zodToJsonSchema]
+ * });
+ *
+ * const asyncapi = await generator.generate(contract, {
+ *   id: 'urn:com:example:order-service',
+ *   info: {
+ *     title: 'Order Service API',
+ *     version: '1.0.0',
+ *     description: 'Async API for order processing'
+ *   },
+ *   servers: {
+ *     production: {
+ *       host: 'rabbitmq.example.com',
+ *       protocol: 'amqp',
+ *       protocolVersion: '0.9.1'
+ *     }
+ *   }
+ * });
  * ```
  */
-declare function standardSchemaToJsonSchema(_schema: StandardSchemaV1): AsyncAPISchema;
+declare class AsyncAPIGenerator {
+  private readonly converters;
+  /**
+   * Create a new AsyncAPI generator instance.
+   *
+   * @param options - Configuration options including schema converters
+   */
+  constructor(options?: AsyncAPIGeneratorOptions);
+  /**
+   * Generate an AsyncAPI 3.0 document from a contract definition.
+   *
+   * Converts AMQP exchanges, queues, publishers, and consumers into
+   * AsyncAPI channels, operations, and messages with proper JSON Schema
+   * validation definitions.
+   *
+   * @param contract - The AMQP contract definition to convert
+   * @param options - AsyncAPI document metadata (id, info, servers)
+   * @returns Promise resolving to a complete AsyncAPI 3.0 document
+   *
+   * @example
+   * ```typescript
+   * const asyncapi = await generator.generate(contract, {
+   *   id: 'urn:com:example:api',
+   *   info: {
+   *     title: 'My API',
+   *     version: '1.0.0'
+   *   },
+   *   servers: {
+   *     dev: {
+   *       host: 'localhost:5672',
+   *       protocol: 'amqp'
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  generate(contract: ContractDefinition, options: AsyncAPIGeneratorGenerateOptions): Promise<AsyncAPIObject>;
+  /**
+   * Convert a message definition to AsyncAPI MessageObject
+   */
+  private convertMessage;
+  /**
+   * Convert a queue definition to AsyncAPI ChannelObject
+   */
+  private queueToChannel;
+  /**
+   * Convert an exchange definition to AsyncAPI ChannelObject
+   */
+  private exchangeToChannel;
+  /**
+   * Get the name/key of an exchange from the contract
+   */
+  private getExchangeName;
+  /**
+   * Get the name/key of a queue from the contract
+   */
+  private getQueueName;
+  /**
+   * Convert a Standard Schema to JSON Schema using oRPC converters
+   */
+  private convertSchema;
+}
 //#endregion
-export { type AsyncAPIChannel, type AsyncAPIComponents, type AsyncAPIDocument, type AsyncAPIInfo, type AsyncAPIMessageRef, type AsyncAPIOperation, type AsyncAPISchema, type AsyncAPIServer, type GenerateAsyncAPIOptions, generateAsyncAPI, standardSchemaToJsonSchema };
+export { AsyncAPIGenerator, AsyncAPIGeneratorGenerateOptions, AsyncAPIGeneratorOptions };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/generator.ts","../src/schema-converter.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMiB,UAAA,gBAAA,CAAgB;EAEzB,QAAA,EAAA,OAAA;EACmB,IAAA,EADnB,YACmB;EAAf,OAAA,CAAA,EAAA,MAAA,CAAA,MAAA,EAAe,cAAf,CAAA;EACgB,QAAA,CAAA,EAAf,MAAe,CAAA,MAAA,EAAA,eAAA,CAAA;EAAf,UAAA,CAAA,EACE,MADF,CAAA,MAAA,EACiB,iBADjB,CAAA;EACiB,UAAA,CAAA,EACf,kBADe;;AACf,UAGE,YAAA,CAHF;EAAkB,KAAA,EAAA,MAAA;EAGhB,OAAA,EAAA,MAAY;EAgBZ,WAAA,CAAA,EAAA,MAAc;EAOd,cAAA,CAAA,EAAA,MAAe;EAuBf,OAAA,CAAA,EAAA;IAOA,IAAA,CAAA,EAAA,MAAA;IAUA,GAAA,CAAA,EAAA,MAAA;IAEa,KAAA,CAAA,EAAA,MAAA;EAAf,CAAA;EAEL,OAAA,CAAA,EAAA;IAAc,IAAA,EAAA,MAAA;IAYd,GAAA,CAAA,EAAA,MAAW;EAIJ,CAAA;;AACJ,UApEI,cAAA,CAoEJ;EACc,IAAA,EAAA,MAAA;EAAf,QAAA,EAAA,MAAA;EAAM,WAAA,CAAA,EAAA,MAAA;EAMD,SAAA,CAAA,EAvEH,MAuEG,CAAA,MAAA,EAAuB;IAC3B,OAAA,EAAA,MAAA;IAAL,WAAA,CAAA,EAAA,MAAA;EAImB,CAAA,CAAA;;AAAT,UAzED,eAAA,CAyEC;EAMF,OAAA,EAAA,MAAA;EACJ,QAAA,CAAA,EA9EC,MA8ED,CAAA,MAAA,EA9EgB,kBA8EhB,CAAA;EACD,WAAA,CAAA,EAAA,MAAA;EACR,QAAA,CAAA,EAAA;IAAgB,IAAA,CAAA,EAAA;;;;QCnGH,OAAA,CAAA,EAAA,OAA0B;;;;;;;;;;;;;UDwCzB,iBAAA;;WAEN;aACE;;;UAII,kBAAA;;YAEL;;;;;;;UAQK,cAAA;;eAEF,eAAe;;UAEpB;;;;;;;;;;;UAYA,WAAA;;;UAIO,kBAAA;aACJ,eAAe;YAChB,eAAe;;;;;UAMV,uBAAA;QACT,KAAK;;;;YAID,eAAe;;;;;iBAMX,gBAAA,WACJ,6BACD,0BACR;;;;;AAlHH;;;;;;;;;;AASA;AAgBA;AAOA;AAuBA;AAOA;AAUA;AAE8B,iBC3Dd,0BAAA,CD2Dc,OAAA,EC3DsB,gBD2DtB,CAAA,EC3DyC,cD2DzC"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA8BA;AAYA;AAiDA;;;;;;;;;UA7DiB,wBAAA;;;;;qBAKI;;;;;;KAOT,gCAAA,GAAmC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiDvC,iBAAA;;;;;;;wBAQU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiCT,6BACD,mCACR,QAAQ"}

package/dist/index.mjs

@@ -1,110 +1,247 @@
-//#region src/schema-converter.ts
+//#region src/index.ts
 /**
-* Convert a Standard Schema to JSON Schema (AsyncAPI format)
+* Generator for creating AsyncAPI 3.0 documentation from AMQP contracts.
 *
-* This is a basic converter that returns a generic object schema.
-* Users should provide their own schema-to-JSON-Schema converter function
-* specific to their schema library.
-*
-* For Zod users, import and use zodToJsonSchema from @amqp-contract/zod
+* This class converts contract definitions into AsyncAPI 3.0 specification documents,
+* which can be used for API documentation, code generation, and tooling integration.
 *
 * @example
-* ```ts
-* import { zodToJsonSchema } from '@amqp-contract/zod';
-* import { generateAsyncAPI } from '@amqp-contract/asyncapi';
+* ```typescript
+* import { AsyncAPIGenerator } from '@amqp-contract/asyncapi';
+* import { zodToJsonSchema } from '@orpc/zod';
+* import { z } from 'zod';
+*
+* const contract = defineContract({
+*   exchanges: {
+*     orders: defineExchange('orders', 'topic', { durable: true })
+*   },
+*   publishers: {
+*     orderCreated: definePublisher('orders', z.object({
+*       orderId: z.string(),
+*       amount: z.number()
+*     }), {
+*       routingKey: 'order.created'
+*     })
+*   }
+* });
+*
+* const generator = new AsyncAPIGenerator({
+*   schemaConverters: [zodToJsonSchema]
+* });
 *
-* // Use zodToJsonSchema for converting Zod schemas
-* const jsonSchema = zodToJsonSchema(zodSchema);
+* const asyncapi = await generator.generate(contract, {
+*   id: 'urn:com:example:order-service',
+*   info: {
+*     title: 'Order Service API',
+*     version: '1.0.0',
+*     description: 'Async API for order processing'
+*   },
+*   servers: {
+*     production: {
+*       host: 'rabbitmq.example.com',
+*       protocol: 'amqp',
+*       protocolVersion: '0.9.1'
+*     }
+*   }
+* });
 * ```
 */
-function standardSchemaToJsonSchema(_schema) {
-	return { type: "object" };
-}
-
-//#endregion
-//#region src/generator.ts
-/**
-* Generate AsyncAPI 3.0.0 specification from AMQP contract
-*/
-function generateAsyncAPI(contract, options) {
-	const channels = {};
-	const operations = {};
-	const messages = {};
-	if (contract.queues) for (const [queueName, queue] of Object.entries(contract.queues)) {
-		const binding = { amqp: {
-			is: "queue",
-			queue: { name: queue.name }
-		} };
-		if (queue.durable !== void 0) binding.amqp.queue.durable = queue.durable;
-		if (queue.exclusive !== void 0) binding.amqp.queue.exclusive = queue.exclusive;
-		if (queue.autoDelete !== void 0) binding.amqp.queue.autoDelete = queue.autoDelete;
-		channels[queueName] = {
-			address: queue.name,
-			description: `Queue: ${queue.name}`,
-			bindings: binding
-		};
+var AsyncAPIGenerator = class {
+	converters;
+	/**
+	* Create a new AsyncAPI generator instance.
+	*
+	* @param options - Configuration options including schema converters
+	*/
+	constructor(options = {}) {
+		this.converters = options.schemaConverters ?? [];
 	}
-	if (contract.exchanges) for (const [exchangeName, exchange] of Object.entries(contract.exchanges)) {
-		const binding = { amqp: {
-			is: "routingKey",
-			exchange: {
-				name: exchange.name,
-				type: exchange.type
+	/**
+	* Generate an AsyncAPI 3.0 document from a contract definition.
+	*
+	* Converts AMQP exchanges, queues, publishers, and consumers into
+	* AsyncAPI channels, operations, and messages with proper JSON Schema
+	* validation definitions.
+	*
+	* @param contract - The AMQP contract definition to convert
+	* @param options - AsyncAPI document metadata (id, info, servers)
+	* @returns Promise resolving to a complete AsyncAPI 3.0 document
+	*
+	* @example
+	* ```typescript
+	* const asyncapi = await generator.generate(contract, {
+	*   id: 'urn:com:example:api',
+	*   info: {
+	*     title: 'My API',
+	*     version: '1.0.0'
+	*   },
+	*   servers: {
+	*     dev: {
+	*       host: 'localhost:5672',
+	*       protocol: 'amqp'
+	*     }
+	*   }
+	* });
+	* ```
+	*/
+	async generate(contract, options) {
+		const convertedChannels = {};
+		const convertedOperations = {};
+		const convertedMessages = {};
+		const publisherMessages = /* @__PURE__ */ new Map();
+		const consumerMessages = /* @__PURE__ */ new Map();
+		if (contract.publishers) for (const [publisherName, publisher] of Object.entries(contract.publishers)) {
+			const channelKey = this.getExchangeName(publisher.exchange, contract);
+			publisherMessages.set(publisherName, {
+				message: publisher.message,
+				channelKey
+			});
+		}
+		if (contract.consumers) for (const [consumerName, consumer] of Object.entries(contract.consumers)) {
+			const channelKey = this.getQueueName(consumer.queue, contract);
+			consumerMessages.set(consumerName, {
+				message: consumer.message,
+				channelKey
+			});
+		}
+		if (contract.queues) for (const [queueName, queue] of Object.entries(contract.queues)) {
+			const channelMessages = {};
+			for (const [consumerName, { message, channelKey }] of consumerMessages) if (channelKey === queueName) {
+				const messageName = `${consumerName}Message`;
+				channelMessages[messageName] = await this.convertMessage(message);
+				convertedMessages[messageName] = await this.convertMessage(message);
 			}
-		} };
-		if (exchange.durable !== void 0) binding.amqp.exchange.durable = exchange.durable;
-		if (exchange.autoDelete !== void 0) binding.amqp.exchange.autoDelete = exchange.autoDelete;
-		channels[exchangeName] = {
-			address: exchange.name,
-			description: `Exchange: ${exchange.name} (${exchange.type})`,
-			bindings: binding
+			const channel = { ...this.queueToChannel(queue) };
+			if (Object.keys(channelMessages).length > 0) channel.messages = channelMessages;
+			convertedChannels[queueName] = channel;
+		}
+		if (contract.exchanges) for (const [exchangeName, exchange] of Object.entries(contract.exchanges)) {
+			const channelMessages = {};
+			for (const [publisherName, { message, channelKey }] of publisherMessages) if (channelKey === exchangeName) {
+				const messageName = `${publisherName}Message`;
+				channelMessages[messageName] = await this.convertMessage(message);
+				convertedMessages[messageName] = await this.convertMessage(message);
+			}
+			const channel = { ...this.exchangeToChannel(exchange) };
+			if (Object.keys(channelMessages).length > 0) channel.messages = channelMessages;
+			convertedChannels[exchangeName] = channel;
+		}
+		if (contract.publishers) for (const [publisherName, publisher] of Object.entries(contract.publishers)) {
+			const exchangeName = this.getExchangeName(publisher.exchange, contract);
+			const messageName = `${publisherName}Message`;
+			convertedOperations[publisherName] = {
+				action: "send",
+				channel: { $ref: `#/channels/${exchangeName}` },
+				messages: [{ $ref: `#/channels/${exchangeName}/messages/${messageName}` }],
+				summary: `Publish to ${publisher.exchange.name}`,
+				...publisher.routingKey && { description: `Routing key: ${publisher.routingKey}` }
+			};
+		}
+		if (contract.consumers) for (const [consumerName, consumer] of Object.entries(contract.consumers)) {
+			const queueName = this.getQueueName(consumer.queue, contract);
+			const messageName = `${consumerName}Message`;
+			convertedOperations[consumerName] = {
+				action: "receive",
+				channel: { $ref: `#/channels/${queueName}` },
+				messages: [{ $ref: `#/channels/${queueName}/messages/${messageName}` }],
+				summary: `Consume from ${consumer.queue.name}`
+			};
+		}
+		return {
+			...options,
+			asyncapi: "3.0.0",
+			channels: convertedChannels,
+			operations: convertedOperations,
+			components: { messages: convertedMessages }
 		};
 	}
-	if (contract.publishers) for (const [publisherName, publisher] of Object.entries(contract.publishers)) {
-		const messageName = `${publisherName}Message`;
-		messages[messageName] = {
-			name: messageName,
-			title: `${publisherName} message`,
-			contentType: "application/json",
-			payload: standardSchemaToJsonSchema(publisher.message)
-		};
-		operations[publisherName] = {
-			action: "send",
-			channel: { $ref: `#/channels/${publisher.exchange}` },
-			messages: [{ $ref: `#/components/messages/${messageName}` }],
-			description: `Publish message to ${publisher.exchange}`
+	/**
+	* Convert a message definition to AsyncAPI MessageObject
+	*/
+	async convertMessage(message) {
+		const payload = message.payload;
+		const result = {
+			payload: await this.convertSchema(payload, "input"),
+			contentType: "application/json"
 		};
+		if (message.headers) {
+			const headersJsonSchema = await this.convertSchema(message.headers, "input");
+			if (headersJsonSchema) result["headers"] = headersJsonSchema;
+		}
+		if (message.summary) result["summary"] = message.summary;
+		if (message.description) result["description"] = message.description;
+		return result;
 	}
-	if (contract.consumers) for (const [consumerName, consumer] of Object.entries(contract.consumers)) {
-		const messageName = `${consumerName}Message`;
-		messages[messageName] = {
-			name: messageName,
-			title: `${consumerName} message`,
-			contentType: "application/json",
-			payload: standardSchemaToJsonSchema(consumer.message)
+	/**
+	* Convert a queue definition to AsyncAPI ChannelObject
+	*/
+	queueToChannel(queue) {
+		return {
+			address: queue.name,
+			title: queue.name,
+			description: `AMQP Queue: ${queue.name}`,
+			bindings: { amqp: {
+				is: "queue",
+				queue: {
+					name: queue.name,
+					durable: queue.durable ?? false,
+					exclusive: queue.exclusive ?? false,
+					autoDelete: queue.autoDelete ?? false,
+					...queue.arguments && { vhost: "/" }
+				}
+			} }
 		};
-		operations[consumerName] = {
-			action: "receive",
-			channel: { $ref: `#/channels/${consumer.queue}` },
-			messages: [{ $ref: `#/components/messages/${messageName}` }],
-			description: `Consume message from ${consumer.queue}`
+	}
+	/**
+	* Convert an exchange definition to AsyncAPI ChannelObject
+	*/
+	exchangeToChannel(exchange) {
+		return {
+			address: exchange.name,
+			title: exchange.name,
+			description: `AMQP Exchange: ${exchange.name} (${exchange.type})`,
+			bindings: { amqp: {
+				is: "routingKey",
+				exchange: {
+					name: exchange.name,
+					type: exchange.type,
+					durable: exchange.durable ?? false,
+					autoDelete: exchange.autoDelete ?? false,
+					...exchange.arguments && { vhost: "/" }
+				}
+			} }
 		};
 	}
-	const result = {
-		asyncapi: "3.0.0",
-		info: {
-			title: options.info.title ?? "AMQP Contract API",
-			version: options.info.version ?? "1.0.0",
-			...options.info
-		},
-		channels,
-		operations,
-		components: { messages }
-	};
-	if (options.servers) result.servers = options.servers;
-	return result;
-}
+	/**
+	* Get the name/key of an exchange from the contract
+	*/
+	getExchangeName(exchange, contract) {
+		if (contract.exchanges) {
+			for (const [name, ex] of Object.entries(contract.exchanges)) if (ex === exchange || ex.name === exchange.name) return name;
+		}
+		return exchange.name;
+	}
+	/**
+	* Get the name/key of a queue from the contract
+	*/
+	getQueueName(queue, contract) {
+		if (contract.queues) {
+			for (const [name, q] of Object.entries(contract.queues)) if (q === queue || q.name === queue.name) return name;
+		}
+		return queue.name;
+	}
+	/**
+	* Convert a Standard Schema to JSON Schema using oRPC converters
+	*/
+	async convertSchema(schema, strategy) {
+		for (const converter of this.converters) if (await converter.condition(schema, { strategy })) {
+			const [_required, jsonSchema] = await converter.convert(schema, { strategy });
+			return jsonSchema;
+		}
+		return { type: "object" };
+	}
+};
 
 //#endregion
-export { generateAsyncAPI, standardSchemaToJsonSchema };
+export { AsyncAPIGenerator };
 //# sourceMappingURL=index.mjs.map