@alagoni97/cli 0.72.1

package/dist/codegen/generators/typescript/channels/protocols/websocket/subscribe.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWebSocketSubscribe = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+/* eslint-disable sonarjs/no-duplicate-string */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderWebSocketSubscribe({ topic, messageType, messageModule, channelParameters, subName = (0, utils_1.pascalCase)(topic), functionName = `subscribeTo${subName}`, description, deprecated }) {
+    let messageUnmarshalling = `${messageType}.unmarshal(receivedData)`;
+    if (messageModule) {
+        messageUnmarshalling = `${messageModule}.unmarshal(receivedData)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const callbackParameters = [
+        'err?: Error',
+        `msg?: ${messageType}`,
+        ...(channelParameters ? [`parameters?: ${channelParameters.type}`] : []),
+        'ws?: WebSocket.WebSocket'
+    ];
+    const callbackArguments = [
+        'err: undefined',
+        'msg: parsedMessage',
+        ...(channelParameters ? ['parameters'] : []),
+        'ws'
+    ];
+    const errorCallbackArguments = [
+        'err: new Error(`Failed to parse message: ${error.message}`)',
+        'msg: undefined',
+        ...(channelParameters ? ['parameters'] : []),
+        'ws'
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (params: {${callbackParameters.join(', ')}}) => void`,
+            jsDoc: ' * @param onDataCallback callback when messages are received'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for URL path substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'ws',
+            parameterType: 'ws: WebSocket.WebSocket',
+            jsDoc: ' * @param ws the WebSocket connection (assumed to be already connected)'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `WebSocket client-side function to subscribe to messages from \`${topic}\``,
+        parameters: functionParameters.map((param) => ({
+            jsDoc: param.jsDoc
+        }))
+    });
+    const code = `${jsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(',\n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(',\n  ')}
+}): void {
+  try {
+    // Check if WebSocket is open
+    if (ws.readyState !== WebSocket.WebSocket.OPEN) {
+      onDataCallback({
+        err: new Error('WebSocket is not open'),
+        msg: undefined,${channelParameters ? '\n        parameters,' : ''}
+        ws
+      });
+      return;
+    }
+
+    const validator = ${messageModule ? `${messageModule}.createValidator()` : `${messageType}.createValidator()`};
+
+    ws.on('message', (data: WebSocket.RawData) => {
+      try {
+        const receivedData = data.toString();
+        const parsedMessage = ${messageUnmarshalling};
+        
+        // Validate message if validation is enabled
+        if (!skipMessageValidation) {
+          const messageToValidate = ${messageModule ? `${messageModule}.marshal(parsedMessage)` : `parsedMessage.marshal()`};
+          const {valid, errors} = ${messageModule ? `${messageModule}.validate({data: messageToValidate, ajvValidatorFunction: validator})` : `${messageType}.validate({data: messageToValidate, ajvValidatorFunction: validator})`};
+          if (!valid) {
+            onDataCallback({
+              err: new Error(\`Invalid message payload received; \${JSON.stringify({cause: errors})}\`),
+              msg: undefined,${channelParameters ? '\n              parameters,' : ''}
+              ws
+            });
+            return;
+          }
+        }
+
+        onDataCallback({
+          ${callbackArguments.join(',\n          ')}
+        });
+
+      } catch (error: any) {
+        onDataCallback({
+          ${errorCallbackArguments.join(',\n          ')}
+        });
+      }
+    });
+
+    ws.on('error', (error: Error) => {
+      onDataCallback({
+        err: new Error(\`WebSocket error: \${error.message}\`),
+        msg: undefined,${channelParameters ? '\n        parameters,' : ''}
+        ws
+      });
+    });
+
+    ws.on('close', (code: number, reason: Buffer) => {
+      // Only report as error if it's not a normal closure (1000) or going away (1001)
+      if (code !== 1000 && code !== 1001 && code !== 1005) { // 1005 is no status received
+        onDataCallback({
+          err: new Error(\`WebSocket closed unexpectedly: \${code} \${reason.toString()}\`),
+          msg: undefined,${channelParameters ? '\n          parameters,' : ''}
+          ws
+        });
+      }
+    });
+
+  } catch (error: any) {
+    onDataCallback({
+      err: new Error(\`Failed to set up WebSocket subscription: \${error.message}\`),
+      msg: undefined,${channelParameters ? '\n      parameters,' : ''}
+      ws
+    });
+  }
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as WebSocket from 'ws';`],
+        functionType: __1.ChannelFunctionTypes.WEBSOCKET_SUBSCRIBE
+    };
+}
+exports.renderWebSocketSubscribe = renderWebSocketSubscribe;

package/dist/codegen/generators/typescript/channels/types.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { GenericCodegenContext } from '../../../types';
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { TypeScriptPayloadRenderType } from '../payloads';
+import { TypeScriptParameterRenderType } from '../parameters';
+import { ConstrainedObjectModel } from '@asyncapi/modelina';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { SecuritySchemeOptions } from '../../../inputs/openapi/security';
+export { SecuritySchemeOptions };
+export declare enum ChannelFunctionTypes {
+    NATS_JETSTREAM_PUBLISH = "nats_jetstream_publish",
+    NATS_JETSTREAM_PULL_SUBSCRIBE = "nats_jetstream_pull_subscribe",
+    NATS_JETSTREAM_PUSH_SUBSCRIBE = "nats_jetstream_push_subscribe",
+    NATS_SUBSCRIBE = "nats_subscribe",
+    NATS_PUBLISH = "nats_publish",
+    NATS_REQUEST = "nats_request",
+    NATS_REPLY = "nats_reply",
+    MQTT_PUBLISH = "mqtt_publish",
+    MQTT_SUBSCRIBE = "mqtt_subscribe",
+    KAFKA_PUBLISH = "kafka_publish",
+    KAFKA_SUBSCRIBE = "kafka_subscribe",
+    AMQP_QUEUE_PUBLISH = "amqp_queue_publish",
+    AMQP_QUEUE_SUBSCRIBE = "amqp_queue_subscribe",
+    AMQP_EXCHANGE_PUBLISH = "amqp_exchange_publish",
+    HTTP_CLIENT = "http_client",
+    EVENT_SOURCE_FETCH = "event_source_fetch",
+    EVENT_SOURCE_EXPRESS = "event_source_express",
+    WEBSOCKET_PUBLISH = "websocket_publish",
+    WEBSOCKET_SUBSCRIBE = "websocket_subscribe",
+    WEBSOCKET_REGISTER = "websocket_register"
+}
+export declare const sendingFunctionTypes: ChannelFunctionTypes[];
+export declare const receivingFunctionTypes: ChannelFunctionTypes[];
+export declare const zodTypescriptChannelsGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"channels">>;
+    outputPath: z.ZodDefault<z.ZodString>;
+    protocols: z.ZodDefault<z.ZodArray<z.ZodEnum<["nats", "kafka", "mqtt", "amqp", "event_source", "http_client", "websocket"]>, "many">>;
+    parameterGeneratorId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    payloadGeneratorId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    headerGeneratorId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    asyncapiReverseOperations: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    asyncapiGenerateForOperations: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    functionTypeMapping: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ChannelFunctionTypes>, "many">>>>>;
+    kafkaTopicSeparator: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    eventSourceDependency: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+    importExtension: z.ZodOptional<z.ZodEnum<[".ts", ".js", "none"]>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "channels";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    protocols: ("http_client" | "nats" | "kafka" | "mqtt" | "amqp" | "event_source" | "websocket")[];
+    parameterGeneratorId: string;
+    payloadGeneratorId: string;
+    headerGeneratorId: string;
+    asyncapiReverseOperations: boolean;
+    asyncapiGenerateForOperations: boolean;
+    functionTypeMapping: Record<string, ChannelFunctionTypes[] | undefined>;
+    kafkaTopicSeparator: string;
+    eventSourceDependency: string;
+    importExtension?: ".ts" | ".js" | "none" | undefined;
+}, {
+    preset?: "channels" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    protocols?: ("http_client" | "nats" | "kafka" | "mqtt" | "amqp" | "event_source" | "websocket")[] | undefined;
+    parameterGeneratorId?: string | undefined;
+    payloadGeneratorId?: string | undefined;
+    headerGeneratorId?: string | undefined;
+    asyncapiReverseOperations?: boolean | undefined;
+    asyncapiGenerateForOperations?: boolean | undefined;
+    functionTypeMapping?: Record<string, ChannelFunctionTypes[] | undefined> | undefined;
+    kafkaTopicSeparator?: string | undefined;
+    eventSourceDependency?: string | undefined;
+    importExtension?: ".ts" | ".js" | "none" | undefined;
+}>;
+export type TypeScriptChannelsGenerator = z.input<typeof zodTypescriptChannelsGenerator>;
+export type TypeScriptChannelsGeneratorInternal = z.infer<typeof zodTypescriptChannelsGenerator>;
+export declare const defaultTypeScriptChannelsGenerator: TypeScriptChannelsGeneratorInternal;
+export interface TypeScriptChannelsContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypeScriptChannelsGeneratorInternal;
+}
+export interface TypeScriptChannelsGeneratorContext extends TypeScriptChannelsContext {
+    payloads: TypeScriptPayloadRenderType;
+    parameter: ConstrainedObjectModel | undefined;
+    headers: ConstrainedObjectModel | undefined;
+    topic: string;
+    subName: string;
+}
+export type TypeScriptChannelRenderedFunctionType = {
+    functionType: ChannelFunctionTypes;
+    functionName: string;
+    messageType: string;
+    replyType?: string;
+    parameterType?: string;
+};
+export interface TypeScriptChannelRenderType {
+    payloadRender: TypeScriptPayloadRenderType;
+    parameterRender: TypeScriptParameterRenderType;
+    generator: TypeScriptChannelsGeneratorInternal;
+    /**
+     * All the rendered functions based on type.
+     */
+    renderedFunctions: Record<string, TypeScriptChannelRenderedFunctionType[]>;
+    /**
+     * The generated index file content (imports and re-exports of protocol modules).
+     */
+    result: string;
+    /**
+     * The generated protocol file contents, keyed by protocol name.
+     * E.g., { nats: "export function publish...", kafka: "export function produce..." }
+     * Useful for testing/snapshot verification of generated protocol code.
+     */
+    protocolFiles: Record<string, string>;
+    /**
+     * Generated files with path and content.
+     */
+    files: import('../../../types').GeneratedFile[];
+}
+export interface RenderRegularParameters<T = any> {
+    topic: string;
+    messageType: string;
+    messageModule?: string;
+    channelParameters: ConstrainedObjectModel | undefined;
+    channelHeaders: ConstrainedObjectModel | undefined;
+    subName?: string;
+    functionName?: string;
+    payloadGenerator: TypeScriptPayloadRenderType;
+    additionalProperties?: T;
+    /** Operation description from API specification for JSDoc generation */
+    description?: string;
+    /** Whether the operation is marked as deprecated in the API specification */
+    deprecated?: boolean;
+}
+export interface RenderRequestReplyParameters {
+    requestTopic: string;
+    requestMessageType: string;
+    requestMessageModule: string | undefined;
+    replyMessageType: string;
+    replyMessageModule: string | undefined;
+    channelParameters: ConstrainedObjectModel | undefined;
+    channelHeaders: ConstrainedObjectModel | undefined;
+    subName?: string;
+    functionName?: string;
+    payloadGenerator: TypeScriptPayloadRenderType;
+    /** Operation description from API specification for JSDoc generation */
+    description?: string;
+    /** Whether the operation is marked as deprecated in the API specification */
+    deprecated?: boolean;
+}
+export interface RenderHttpParameters {
+    requestTopic: string;
+    requestMessageType?: string;
+    servers?: string[];
+    requestMessageModule: string | undefined;
+    replyMessageType: string;
+    replyMessageModule: string | undefined;
+    channelParameters: ConstrainedObjectModel | undefined;
+    subName?: string;
+    functionName?: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+    /**
+     * Whether the reply payload includes status code-based unmarshalling.
+     * When true, use unmarshalByStatusCode(json, statusCode) instead of unmarshal(json).
+     */
+    includesStatusCodes?: boolean;
+    /** Operation description from API specification for JSDoc generation */
+    description?: string;
+    /** Whether the operation is marked as deprecated in the API specification */
+    deprecated?: boolean;
+}
+export type SupportedProtocols = 'nats' | 'kafka' | 'mqtt' | 'amqp' | 'event_source' | 'http_client' | 'websocket';

package/dist/codegen/generators/typescript/channels/types.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptChannelsGenerator = exports.zodTypescriptChannelsGenerator = exports.receivingFunctionTypes = exports.sendingFunctionTypes = exports.ChannelFunctionTypes = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+var ChannelFunctionTypes;
+(function (ChannelFunctionTypes) {
+    ChannelFunctionTypes["NATS_JETSTREAM_PUBLISH"] = "nats_jetstream_publish";
+    ChannelFunctionTypes["NATS_JETSTREAM_PULL_SUBSCRIBE"] = "nats_jetstream_pull_subscribe";
+    ChannelFunctionTypes["NATS_JETSTREAM_PUSH_SUBSCRIBE"] = "nats_jetstream_push_subscribe";
+    ChannelFunctionTypes["NATS_SUBSCRIBE"] = "nats_subscribe";
+    ChannelFunctionTypes["NATS_PUBLISH"] = "nats_publish";
+    ChannelFunctionTypes["NATS_REQUEST"] = "nats_request";
+    ChannelFunctionTypes["NATS_REPLY"] = "nats_reply";
+    ChannelFunctionTypes["MQTT_PUBLISH"] = "mqtt_publish";
+    ChannelFunctionTypes["MQTT_SUBSCRIBE"] = "mqtt_subscribe";
+    ChannelFunctionTypes["KAFKA_PUBLISH"] = "kafka_publish";
+    ChannelFunctionTypes["KAFKA_SUBSCRIBE"] = "kafka_subscribe";
+    ChannelFunctionTypes["AMQP_QUEUE_PUBLISH"] = "amqp_queue_publish";
+    ChannelFunctionTypes["AMQP_QUEUE_SUBSCRIBE"] = "amqp_queue_subscribe";
+    ChannelFunctionTypes["AMQP_EXCHANGE_PUBLISH"] = "amqp_exchange_publish";
+    ChannelFunctionTypes["HTTP_CLIENT"] = "http_client";
+    ChannelFunctionTypes["EVENT_SOURCE_FETCH"] = "event_source_fetch";
+    ChannelFunctionTypes["EVENT_SOURCE_EXPRESS"] = "event_source_express";
+    ChannelFunctionTypes["WEBSOCKET_PUBLISH"] = "websocket_publish";
+    ChannelFunctionTypes["WEBSOCKET_SUBSCRIBE"] = "websocket_subscribe";
+    ChannelFunctionTypes["WEBSOCKET_REGISTER"] = "websocket_register";
+})(ChannelFunctionTypes || (exports.ChannelFunctionTypes = ChannelFunctionTypes = {}));
+exports.sendingFunctionTypes = [
+    ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH,
+    ChannelFunctionTypes.NATS_PUBLISH,
+    ChannelFunctionTypes.NATS_REQUEST,
+    ChannelFunctionTypes.MQTT_PUBLISH,
+    ChannelFunctionTypes.KAFKA_PUBLISH,
+    ChannelFunctionTypes.AMQP_EXCHANGE_PUBLISH,
+    ChannelFunctionTypes.AMQP_QUEUE_PUBLISH,
+    ChannelFunctionTypes.EVENT_SOURCE_EXPRESS,
+    ChannelFunctionTypes.HTTP_CLIENT,
+    ChannelFunctionTypes.WEBSOCKET_PUBLISH,
+    ChannelFunctionTypes.WEBSOCKET_REGISTER
+];
+exports.receivingFunctionTypes = [
+    ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE,
+    ChannelFunctionTypes.NATS_JETSTREAM_PUSH_SUBSCRIBE,
+    ChannelFunctionTypes.NATS_REPLY,
+    ChannelFunctionTypes.NATS_SUBSCRIBE,
+    ChannelFunctionTypes.MQTT_SUBSCRIBE,
+    ChannelFunctionTypes.KAFKA_SUBSCRIBE,
+    ChannelFunctionTypes.EVENT_SOURCE_FETCH,
+    ChannelFunctionTypes.AMQP_QUEUE_SUBSCRIBE,
+    ChannelFunctionTypes.WEBSOCKET_SUBSCRIBE
+];
+exports.zodTypescriptChannelsGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('channels-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([
+        'parameters-typescript',
+        'payloads-typescript',
+        'headers-typescript'
+    ])
+        .describe('The list of other generator IDs that this generator depends on. The channels generator depends on the parameters, payloads, and headers generators by default. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    preset: zod_1.z
+        .literal('channels')
+        .default('channels')
+        .describe('Generates protocol-specific publish/subscribe/request/reply functions for each channel or operation. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    outputPath: zod_1.z
+        .string()
+        .default('src/__gen__/channels')
+        .describe('The directory path where the generated channel functions will be written. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    protocols: zod_1.z
+        .array(zod_1.z.enum([
+        'nats',
+        'kafka',
+        'mqtt',
+        'amqp',
+        'event_source',
+        'http_client',
+        'websocket'
+    ]))
+        .default([])
+        .describe('The protocols to generate channel functions for. Each protocol produces typed publish/subscribe/request/reply functions tailored to that messaging system. [Read more about supported protocols here](https://the-codegen-project.org/docs/getting-started/protocols)'),
+    parameterGeneratorId: zod_1.z
+        .string()
+        .optional()
+        .describe('When multiple TypeScript parameter generators are configured, specify which one this channels generator should depend on. Defaults to "parameters-typescript". [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)')
+        .default('parameters-typescript'),
+    payloadGeneratorId: zod_1.z
+        .string()
+        .optional()
+        .describe('When multiple TypeScript payload generators are configured, specify which one this channels generator should depend on. Defaults to "payloads-typescript". [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)')
+        .default('payloads-typescript'),
+    headerGeneratorId: zod_1.z
+        .string()
+        .optional()
+        .describe('When multiple TypeScript header generators are configured, specify which one this channels generator should depend on. Defaults to "headers-typescript". [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)')
+        .default('headers-typescript'),
+    asyncapiReverseOperations: zod_1.z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true, AsyncAPI operations are generated with their action reversed (a "send" operation becomes "receive" and vice versa). Often used to generate the opposite side of an API for testing. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    asyncapiGenerateForOperations: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When true (default), only the operations defined in the AsyncAPI document are generated and their declared action is enforced. When false, more generic channel functions are generated regardless of the operation action. [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    functionTypeMapping: zod_1.z
+        .record(zod_1.z.array(zod_1.z.nativeEnum(ChannelFunctionTypes)).optional())
+        .optional()
+        .default({})
+        .describe('Used with AsyncAPI input to map a channel ID to the specific channel function types that should be rendered for it (e.g. "nats_publish", "kafka_subscribe"). [Read more about the channels generator here](https://the-codegen-project.org/docs/generators/channels)'),
+    kafkaTopicSeparator: zod_1.z
+        .string()
+        .optional()
+        .default('.')
+        .describe('The separator used when converting AsyncAPI channel addresses into Kafka topic names. For example, with the default ".", an address like "my/resource/path" becomes "my.resource.path". [Read more about the Kafka protocol here](https://the-codegen-project.org/docs/protocols/kafka)'),
+    eventSourceDependency: zod_1.z
+        .string()
+        .optional()
+        .default('@microsoft/fetch-event-source')
+        .describe('The npm package used as the EventSource (Server-Sent Events) client implementation. Override this when you need a fork or alternative because @microsoft/fetch-event-source is out of date in some areas. [Read more about the EventSource protocol here](https://the-codegen-project.org/docs/protocols/eventsource)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript'),
+    importExtension: utils_1.zodImportExtension.describe('File extension appended to relative import paths in generated channel code. Use ".ts" for moduleResolution: "node16"/"nodenext", ".js" for compiled ESM output, or "none" (default) for bundlers. Overrides the global importExtension. [Read more about import extensions here](https://the-codegen-project.org/docs/configurations)')
+});
+exports.defaultTypeScriptChannelsGenerator = exports.zodTypescriptChannelsGenerator.parse({});

package/dist/codegen/generators/typescript/channels/utils.d.ts

@@ -0,0 +1,64 @@
+import { OutputModel } from '@asyncapi/modelina';
+import { ChannelPayload } from '../../../types';
+import { ImportExtension } from '../../../utils';
+import { TypeScriptPayloadRenderType } from '../payloads';
+import { TypeScriptParameterRenderType } from '../parameters';
+import { TypeScriptHeadersRenderType } from '../headers';
+import { TypeScriptChannelsContext } from './types';
+export declare function addPayloadsToDependencies(models: ChannelPayload[], payloadGenerator: {
+    outputPath: string;
+}, currentGenerator: {
+    outputPath: string;
+}, dependencies: string[], importExtension?: ImportExtension): void;
+export declare function addPayloadsToExports(models: ChannelPayload[], dependencies: string[]): void;
+export declare function addParametersToDependencies(parameters: Record<string, OutputModel | undefined>, parameterGenerator: {
+    outputPath: string;
+}, currentGenerator: {
+    outputPath: string;
+}, dependencies: string[], importExtension?: ImportExtension): void;
+export declare function addParametersToExports(parameters: Record<string, OutputModel | undefined>, dependencies: string[]): void;
+export declare function addHeadersToDependencies(headers: Record<string, OutputModel | undefined>, headerGenerator: {
+    outputPath: string;
+}, currentGenerator: {
+    outputPath: string;
+}, dependencies: string[], importExtension?: ImportExtension): void;
+export declare function getMessageTypeAndModule(payload: ChannelPayload): {
+    messageType: undefined;
+    messageModule: undefined;
+    includesStatusCodes: boolean;
+} | {
+    messageType: string;
+    messageModule: string | undefined;
+    includesStatusCodes: boolean;
+};
+export declare function getValidationFunctions({ includeValidation, messageModule, messageType, onValidationFail }: {
+    includeValidation: boolean;
+    messageModule?: string;
+    messageType: string;
+    onValidationFail: string;
+}): {
+    potentialValidatorCreation: string;
+    potentialValidationFunction: string;
+};
+/**
+ * Collects all payload, parameter, and header imports for a specific protocol's dependencies.
+ * This should be called once per protocol to add the necessary imports.
+ */
+export declare function collectProtocolDependencies(payloads: TypeScriptPayloadRenderType, parameters: TypeScriptParameterRenderType, headers: TypeScriptHeadersRenderType | undefined, context: TypeScriptChannelsContext, protocolDeps: string[], importExtension?: ImportExtension): void;
+/**
+ * Escapes special characters in description for JSDoc.
+ * Handles closing comment markers and formats multi-line descriptions.
+ */
+export declare function escapeJSDocDescription(description: string): string;
+/**
+ * Renders JSDoc block for channel functions.
+ * Uses operation description from API spec when available, falls back to generic text.
+ */
+export declare function renderChannelJSDoc(params: {
+    description?: string;
+    deprecated?: boolean;
+    fallbackDescription: string;
+    parameters?: Array<{
+        jsDoc: string;
+    }>;
+}): string;