@alagoni97/cli 0.72.1

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

@@ -0,0 +1,38 @@
+import { ConstrainedObjectModel, typeScriptDefaultPropertyKeyConstraints, TypeScriptOptions } from '@asyncapi/modelina';
+import { DeepPartial } from '../../utils';
+/**
+ * Cast JSON schema variable to typescript type
+ *
+ * @param {string} jsonSchemaType
+ * @param {string} variableToCast
+ */
+export declare function castToTsType(jsonSchemaType: string, variableToCast: string): string;
+/**
+ * Realize parameters without using types and without trailing comma
+ *
+ * @param {Object.<string, ChannelParameter>} parameters
+ * @returns
+ */
+export declare function realizeParametersForChannelWithoutType(parameters: ConstrainedObjectModel): string;
+/**
+ * Realize parameters using types without trailing comma
+ * @param {Object.<string, ChannelParameter>} channelParameters parameters to realize
+ * @param {boolean} required optional or required
+ */
+export declare function realizeParametersForChannel(channelParameters: ConstrainedObjectModel, required?: boolean): string;
+/**
+ * Convert RFC 6570 URI with parameters to NATS topic.
+ */
+export declare function realizeChannelName(channelName: string, parameters?: ConstrainedObjectModel): string;
+/**
+ * Realize channel name to NATS topic without replacing parameters
+ *
+ * @param {string} channelName
+ */
+export declare function realizeChannelNameWithoutParameters(channelName: string): string;
+export declare function camelCase(value: string): string;
+export declare function pascalCase(value: string): string;
+export declare function findRegexFromChannel(channel: string): string;
+export declare const RESERVED_TYPESCRIPT_KEYWORDS: string[];
+export declare const defaultCodegenTypescriptModelinaOptions: DeepPartial<TypeScriptOptions>;
+export { typeScriptDefaultPropertyKeyConstraints };

package/dist/codegen/generators/typescript/utils.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeScriptDefaultPropertyKeyConstraints = exports.defaultCodegenTypescriptModelinaOptions = exports.RESERVED_TYPESCRIPT_KEYWORDS = exports.findRegexFromChannel = exports.pascalCase = exports.camelCase = exports.realizeChannelNameWithoutParameters = exports.realizeChannelName = exports.realizeParametersForChannel = exports.realizeParametersForChannelWithoutType = exports.castToTsType = void 0;
+const modelina_1 = require("@asyncapi/modelina");
+Object.defineProperty(exports, "typeScriptDefaultPropertyKeyConstraints", { enumerable: true, get: function () { return modelina_1.typeScriptDefaultPropertyKeyConstraints; } });
+/**
+ * Cast JSON schema variable to typescript type
+ *
+ * @param {string} jsonSchemaType
+ * @param {string} variableToCast
+ */
+function castToTsType(jsonSchemaType, variableToCast) {
+    switch (jsonSchemaType.toLowerCase()) {
+        case 'string': {
+            return `"" + ${variableToCast}`;
+        }
+        case 'integer':
+        case 'number': {
+            return `Number(${variableToCast})`;
+        }
+        case 'boolean': {
+            return `Boolean(${variableToCast})`;
+        }
+        default: {
+            throw new Error(`Parameter type not supported - ${jsonSchemaType}`);
+        }
+    }
+}
+exports.castToTsType = castToTsType;
+/**
+ * Realize parameters without using types and without trailing comma
+ *
+ * @param {Object.<string, ChannelParameter>} parameters
+ * @returns
+ */
+function realizeParametersForChannelWithoutType(parameters) {
+    let returnString = '';
+    for (const paramName in Object.keys(parameters.properties)) {
+        returnString += `${paramName},`;
+    }
+    if (returnString.length > 0) {
+        returnString = returnString.slice(0, -1);
+    }
+    return returnString;
+}
+exports.realizeParametersForChannelWithoutType = realizeParametersForChannelWithoutType;
+/**
+ * Realize parameters using types without trailing comma
+ * @param {Object.<string, ChannelParameter>} channelParameters parameters to realize
+ * @param {boolean} required optional or required
+ */
+function realizeParametersForChannel(channelParameters, required = true) {
+    let returnString = '';
+    for (const parameter of Object.values(channelParameters.properties)) {
+        returnString += `${realizeParameterForChannelWithType(parameter.propertyName, parameter.property.type, required)},`;
+    }
+    if (returnString.length > 0) {
+        returnString = returnString.slice(0, -1);
+    }
+    return returnString;
+}
+exports.realizeParametersForChannel = realizeParametersForChannel;
+/**
+ * Realize a single parameter with its type
+ *
+ * @param {string} parameterName parameter name to use as
+ * @param {ChannelParameter} parameter which contains the schema
+ * @param {boolean} required should it be optional or required
+ */
+function realizeParameterForChannelWithType(parameterName, parameterType, required = true) {
+    const requiredType = required ? '' : '?';
+    return `${parameterName}${requiredType}: ${parameterType})}`;
+}
+/**
+ * Convert RFC 6570 URI with parameters to NATS topic.
+ */
+function realizeChannelName(channelName, parameters) {
+    let returnString = `\`${channelName}\``;
+    returnString = returnString.replace(/\//g, '.');
+    for (const paramName in parameters) {
+        returnString = returnString.replace(`{${paramName}}`, `\${${paramName}}`);
+    }
+    return returnString;
+}
+exports.realizeChannelName = realizeChannelName;
+/**
+ * Realize channel name to NATS topic without replacing parameters
+ *
+ * @param {string} channelName
+ */
+function realizeChannelNameWithoutParameters(channelName) {
+    return realizeChannelName(channelName);
+}
+exports.realizeChannelNameWithoutParameters = realizeChannelNameWithoutParameters;
+function camelCase(value) {
+    return modelina_1.FormatHelpers.toCamelCase(value);
+}
+exports.camelCase = camelCase;
+function pascalCase(value) {
+    return modelina_1.FormatHelpers.toPascalCase(value);
+}
+exports.pascalCase = pascalCase;
+function findRegexFromChannel(channel) {
+    let topicWithWildcardGroup = channel.replace(/\//g, '\\/');
+    topicWithWildcardGroup = topicWithWildcardGroup.replace(/{[^}]+}/g, '([^.]*)');
+    return `/^${topicWithWildcardGroup}$/`;
+}
+exports.findRegexFromChannel = findRegexFromChannel;
+exports.RESERVED_TYPESCRIPT_KEYWORDS = [
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'import',
+    'in',
+    'instanceof',
+    'new',
+    'null',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'any',
+    'boolean',
+    'constructor',
+    'declare',
+    'get',
+    'module',
+    'require',
+    'number',
+    'set',
+    'string',
+    'symbol',
+    'type',
+    'from',
+    'of',
+    // Strict mode reserved words
+    'arguments',
+    'as',
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'yield'
+];
+exports.defaultCodegenTypescriptModelinaOptions = {
+    constraints: {
+        modelName: (0, modelina_1.typeScriptDefaultModelNameConstraints)({
+            NO_RESERVED_KEYWORDS: (name) => {
+                // Since all names are pascal we can ignore reserved keywords.
+                return name;
+            },
+            NO_SPECIAL_CHAR: (name) => {
+                // Looks nicer with no special cases at all
+                return name.replace(/\W/g, ' ');
+            }
+        }),
+        propertyKey: (0, modelina_1.typeScriptDefaultPropertyKeyConstraints)({
+            NO_RESERVED_KEYWORDS: (value) => {
+                return (0, modelina_1.NO_RESERVED_KEYWORDS)(value, (word) => 
+                // Filter out all the keywords that does not ruin the code
+                (0, modelina_1.checkForReservedKeyword)(word, exports.RESERVED_TYPESCRIPT_KEYWORDS.filter((filteredValue) => {
+                    return filteredValue !== 'type';
+                }), true));
+            }
+        })
+    }
+};

package/dist/codegen/index.d.ts

@@ -0,0 +1,7 @@
+export { loadAsyncapi } from './inputs/asyncapi';
+export { loadOpenapi } from './inputs/openapi';
+export { loadJsonSchema } from './inputs/jsonschema';
+export { defaultTypeScriptChannelsGenerator, defaultTypeScriptParametersOptions, defaultTypeScriptPayloadGenerator, defaultTypeScriptClientGenerator, defaultCustomGenerator, defaultTypeScriptHeadersOptions, TypeScriptClientGenerator, TypeScriptChannelsGenerator, TypeScriptPayloadGenerator, TypescriptParametersGenerator, TypescriptHeadersGenerator, generateTypeScriptChannels, generateTypescriptParameters, generateTypescriptPayload, generateTypeScriptClient, generateTypescriptHeaders, runGenerators, CustomGenerator, ChannelFunctionTypes } from './generators';
+export { RunGeneratorContext, SupportedLanguages, PresetTypes, TheCodegenConfiguration, TheCodegenConfigurationInternal, zodAsyncAPICodegenConfiguration, zodAsyncAPIGenerators, zodAsyncAPITypeScriptGenerators, zodTheCodegenConfiguration, Generators, GenericCodegenContext, LoadArgument, ParameterRenderType, PayloadRenderType, SingleFunctionRenderType, ChannelPayload, GeneratorsInternal, HeadersRenderType, GenerationResult, GeneratorResult } from './types';
+export { getDefaultConfiguration, realizeConfiguration, loadAndRealizeConfigFile, loadConfigFile, realizeGeneratorContext } from './configurations';
+export { renderGenerator, determineRenderGraph, renderGraph } from './renderer';

package/dist/codegen/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGraph = exports.determineRenderGraph = exports.renderGenerator = exports.realizeGeneratorContext = exports.loadConfigFile = exports.loadAndRealizeConfigFile = exports.realizeConfiguration = exports.getDefaultConfiguration = exports.zodTheCodegenConfiguration = exports.zodAsyncAPITypeScriptGenerators = exports.zodAsyncAPIGenerators = exports.zodAsyncAPICodegenConfiguration = exports.ChannelFunctionTypes = exports.runGenerators = exports.generateTypescriptHeaders = exports.generateTypeScriptClient = exports.generateTypescriptPayload = exports.generateTypescriptParameters = exports.generateTypeScriptChannels = exports.defaultTypeScriptHeadersOptions = exports.defaultCustomGenerator = exports.defaultTypeScriptClientGenerator = exports.defaultTypeScriptPayloadGenerator = exports.defaultTypeScriptParametersOptions = exports.defaultTypeScriptChannelsGenerator = exports.loadJsonSchema = exports.loadOpenapi = exports.loadAsyncapi = void 0;
+var asyncapi_1 = require("./inputs/asyncapi");
+Object.defineProperty(exports, "loadAsyncapi", { enumerable: true, get: function () { return asyncapi_1.loadAsyncapi; } });
+var openapi_1 = require("./inputs/openapi");
+Object.defineProperty(exports, "loadOpenapi", { enumerable: true, get: function () { return openapi_1.loadOpenapi; } });
+var jsonschema_1 = require("./inputs/jsonschema");
+Object.defineProperty(exports, "loadJsonSchema", { enumerable: true, get: function () { return jsonschema_1.loadJsonSchema; } });
+var generators_1 = require("./generators");
+Object.defineProperty(exports, "defaultTypeScriptChannelsGenerator", { enumerable: true, get: function () { return generators_1.defaultTypeScriptChannelsGenerator; } });
+Object.defineProperty(exports, "defaultTypeScriptParametersOptions", { enumerable: true, get: function () { return generators_1.defaultTypeScriptParametersOptions; } });
+Object.defineProperty(exports, "defaultTypeScriptPayloadGenerator", { enumerable: true, get: function () { return generators_1.defaultTypeScriptPayloadGenerator; } });
+Object.defineProperty(exports, "defaultTypeScriptClientGenerator", { enumerable: true, get: function () { return generators_1.defaultTypeScriptClientGenerator; } });
+Object.defineProperty(exports, "defaultCustomGenerator", { enumerable: true, get: function () { return generators_1.defaultCustomGenerator; } });
+Object.defineProperty(exports, "defaultTypeScriptHeadersOptions", { enumerable: true, get: function () { return generators_1.defaultTypeScriptHeadersOptions; } });
+Object.defineProperty(exports, "generateTypeScriptChannels", { enumerable: true, get: function () { return generators_1.generateTypeScriptChannels; } });
+Object.defineProperty(exports, "generateTypescriptParameters", { enumerable: true, get: function () { return generators_1.generateTypescriptParameters; } });
+Object.defineProperty(exports, "generateTypescriptPayload", { enumerable: true, get: function () { return generators_1.generateTypescriptPayload; } });
+Object.defineProperty(exports, "generateTypeScriptClient", { enumerable: true, get: function () { return generators_1.generateTypeScriptClient; } });
+Object.defineProperty(exports, "generateTypescriptHeaders", { enumerable: true, get: function () { return generators_1.generateTypescriptHeaders; } });
+Object.defineProperty(exports, "runGenerators", { enumerable: true, get: function () { return generators_1.runGenerators; } });
+Object.defineProperty(exports, "ChannelFunctionTypes", { enumerable: true, get: function () { return generators_1.ChannelFunctionTypes; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "zodAsyncAPICodegenConfiguration", { enumerable: true, get: function () { return types_1.zodAsyncAPICodegenConfiguration; } });
+Object.defineProperty(exports, "zodAsyncAPIGenerators", { enumerable: true, get: function () { return types_1.zodAsyncAPIGenerators; } });
+Object.defineProperty(exports, "zodAsyncAPITypeScriptGenerators", { enumerable: true, get: function () { return types_1.zodAsyncAPITypeScriptGenerators; } });
+Object.defineProperty(exports, "zodTheCodegenConfiguration", { enumerable: true, get: function () { return types_1.zodTheCodegenConfiguration; } });
+var configurations_1 = require("./configurations");
+Object.defineProperty(exports, "getDefaultConfiguration", { enumerable: true, get: function () { return configurations_1.getDefaultConfiguration; } });
+Object.defineProperty(exports, "realizeConfiguration", { enumerable: true, get: function () { return configurations_1.realizeConfiguration; } });
+Object.defineProperty(exports, "loadAndRealizeConfigFile", { enumerable: true, get: function () { return configurations_1.loadAndRealizeConfigFile; } });
+Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return configurations_1.loadConfigFile; } });
+Object.defineProperty(exports, "realizeGeneratorContext", { enumerable: true, get: function () { return configurations_1.realizeGeneratorContext; } });
+var renderer_1 = require("./renderer");
+Object.defineProperty(exports, "renderGenerator", { enumerable: true, get: function () { return renderer_1.renderGenerator; } });
+Object.defineProperty(exports, "determineRenderGraph", { enumerable: true, get: function () { return renderer_1.determineRenderGraph; } });
+Object.defineProperty(exports, "renderGraph", { enumerable: true, get: function () { return renderer_1.renderGraph; } });

package/dist/codegen/inputs/asyncapi/generators/headers.d.ts

@@ -0,0 +1,3 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { ProcessedHeadersData } from '../../../generators/typescript/headers';
+export declare function processAsyncAPIHeaders(asyncapiDocument: AsyncAPIDocumentInterface): ProcessedHeadersData;

package/dist/codegen/inputs/asyncapi/generators/headers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAsyncAPIHeaders = void 0;
+const utils_1 = require("../../../generators/typescript/utils");
+const modelina_1 = require("@asyncapi/modelina");
+// AsyncAPI input processor
+function processAsyncAPIHeaders(asyncapiDocument) {
+    const channelHeaders = {};
+    for (const channel of asyncapiDocument.allChannels().all()) {
+        const messages = channel.messages().all();
+        let hasHeadersInChannel = false;
+        for (const message of messages) {
+            if (message.hasHeaders()) {
+                let schemaObj;
+                const schema = modelina_1.AsyncAPIInputProcessor.convertToInternalSchema(message.headers());
+                if (typeof schema === 'boolean') {
+                    schemaObj = schema;
+                }
+                else {
+                    schemaObj = {
+                        type: 'object',
+                        ...schema,
+                        $id: (0, utils_1.pascalCase)(`${message.id()}_headers`),
+                        $schema: 'http://json-schema.org/draft-07/schema'
+                    };
+                }
+                channelHeaders[channel.id()] = {
+                    schema: schemaObj,
+                    schemaId: (0, utils_1.pascalCase)(`${message.id()}_headers`)
+                };
+                hasHeadersInChannel = true;
+                break; // Use first message with headers for the channel
+            }
+        }
+        if (!hasHeadersInChannel) {
+            channelHeaders[channel.id()] = undefined;
+        }
+    }
+    return { channelHeaders };
+}
+exports.processAsyncAPIHeaders = processAsyncAPIHeaders;

package/dist/codegen/inputs/asyncapi/generators/parameters.d.ts

@@ -0,0 +1,14 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { ConstrainedObjectModel, TypeScriptFileGenerator } from '@asyncapi/modelina';
+export interface ProcessedParameterSchemaData {
+    channelParameters: Record<string, {
+        schema: any;
+        schemaId: string;
+    }>;
+}
+export declare function processAsyncAPIParameters(asyncapiDocument: AsyncAPIDocumentInterface): Promise<ProcessedParameterSchemaData>;
+/**
+ * Component which contains the parameter unwrapping functionality.
+ */
+export declare function unwrap(channelParameters: ConstrainedObjectModel): string;
+export declare function createAsyncAPIGenerator(): TypeScriptFileGenerator;

package/dist/codegen/inputs/asyncapi/generators/parameters.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncAPIGenerator = exports.unwrap = exports.processAsyncAPIParameters = void 0;
+const utils_1 = require("../../../generators/typescript/utils");
+const utils_2 = require("../../../utils");
+const modelina_1 = require("@asyncapi/modelina");
+// AsyncAPI parameter processor
+async function processAsyncAPIParameters(asyncapiDocument) {
+    const channelParameters = {};
+    for (const channel of asyncapiDocument.allChannels().all()) {
+        const parameters = channel.parameters().all();
+        if (parameters.length > 0) {
+            const channelName = (0, utils_2.findNameFromChannel)(channel);
+            const schemaId = (0, utils_1.pascalCase)(`${channelName}_parameters`);
+            const schemaObj = {
+                type: 'object',
+                $id: schemaId,
+                $schema: 'http://json-schema.org/draft-07/schema',
+                required: [],
+                properties: {},
+                additionalProperties: false,
+                'x-channel-address': channel.address()
+            };
+            for (const parameter of parameters) {
+                schemaObj.properties[parameter.id()] = parameter.schema()?.json();
+                schemaObj.required.push(parameter.id());
+            }
+            channelParameters[channel.id()] = {
+                schema: schemaObj,
+                schemaId
+            };
+        }
+    }
+    return {
+        channelParameters
+    };
+}
+exports.processAsyncAPIParameters = processAsyncAPIParameters;
+/**
+ * Component which contains the parameter unwrapping functionality.
+ */
+function unwrap(channelParameters) {
+    // Nothing to unwrap if no parameters are used
+    if (Object.keys(channelParameters.properties).length === 0) {
+        return '';
+    }
+    // Use channel to iterate over matches as channelParameters.properties might be in incorrect order.
+    const parameterReplacement = Object.values(channelParameters.properties).map((parameter) => {
+        const variableName = `${parameter.propertyName}Match`;
+        return `const ${variableName} = match[sequentialParameters.indexOf('{${parameter.unconstrainedPropertyName}}')+1];
+      if(${variableName} && ${variableName} !== '') {
+        parameters.${parameter.propertyName} = ${variableName} as any
+      } else {
+        throw new Error(\`Parameter: '${parameter.propertyName}' is not valid in ${channelParameters.name}. Aborting parameter extracting! \`) 
+      }`;
+    });
+    const parameterInitializer = Object.values(channelParameters.properties)
+        .filter((parameter) => parameter.property.options.const?.value === undefined)
+        .map((parameter) => {
+        if (parameter.property.options.isNullable) {
+            return `${parameter.propertyName}: null`;
+        }
+        const property = parameter.property;
+        if (property instanceof modelina_1.ConstrainedReferenceModel &&
+            property.ref instanceof modelina_1.ConstrainedEnumModel) {
+            return `${parameter.propertyName}: ${property.ref.values[0].value}`;
+        }
+        return `${parameter.propertyName}: ''`;
+    });
+    return `const parameters = new ${channelParameters.name}({${parameterInitializer.join(', ')}});
+const match = msgSubject.match(regex);
+const sequentialParameters: string[] = channel.match(/\\{(\\w+)\\}/g) || [];
+
+if (match) {
+  ${parameterReplacement.join('\n')}
+} else {
+  throw new Error(\`Unable to find parameters in channel/topic, topic was \${channel}\`)
+}
+return parameters;`;
+}
+exports.unwrap = unwrap;
+/**
+ * Generate additional content for AsyncAPI channel parameter classes
+ */
+function generateAsyncAPIParameterMethods(model) {
+    const parameters = Object.entries(model.properties).map(([, parameter]) => {
+        return `channel = channel.replace(/\\{${parameter.unconstrainedPropertyName}\\}/g, this.${parameter.propertyName})`;
+    });
+    return `/**
+ * Realize the channel/topic with the parameters added to this class.
+ */
+public getChannelWithParameters(channel: string) {
+  ${parameters.length > 0 ? parameters.join(';\n  ') : '// No parameters to replace'};
+  return channel;
+}
+  
+public static createFromChannel(msgSubject: string, channel: string, regex: RegExp): ${model.type} {
+  ${unwrap(model)}
+}`;
+}
+function createAsyncAPIGenerator() {
+    return new modelina_1.TypeScriptFileGenerator({
+        ...utils_1.defaultCodegenTypescriptModelinaOptions,
+        enumType: 'union',
+        useJavascriptReservedKeywords: false,
+        presets: [
+            modelina_1.TS_DESCRIPTION_PRESET,
+            {
+                class: {
+                    additionalContent: ({ content, model }) => {
+                        const additionalMethods = generateAsyncAPIParameterMethods(model);
+                        return `${content}
+${additionalMethods}`;
+                    }
+                }
+            }
+        ]
+    });
+}
+exports.createAsyncAPIGenerator = createAsyncAPIGenerator;

package/dist/codegen/inputs/asyncapi/generators/payloads.d.ts

@@ -0,0 +1,16 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+export interface ProcessedPayloadSchemaData {
+    channelPayloads: Record<string, {
+        schema: any;
+        schemaId: string;
+    }>;
+    operationPayloads: Record<string, {
+        schema: any;
+        schemaId: string;
+    }>;
+    otherPayloads: {
+        schema: any;
+        schemaId: string;
+    }[];
+}
+export declare function processAsyncAPIPayloads(asyncapiDocument: AsyncAPIDocumentInterface): Promise<ProcessedPayloadSchemaData>;

package/dist/codegen/inputs/asyncapi/generators/payloads.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAsyncAPIPayloads = void 0;
+/* eslint-disable security/detect-object-injection */
+const modelina_1 = require("@asyncapi/modelina");
+const utils_1 = require("../../../generators/typescript/utils");
+const utils_2 = require("../../../utils");
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function processAsyncAPIPayloads(asyncapiDocument) {
+    const channelPayloads = {};
+    const operationPayloads = {};
+    const otherPayloads = [];
+    const allChannels = asyncapiDocument.allChannels().all();
+    const processMessages = (messagesToProcess, preId) => {
+        let schemaObj = {
+            type: 'object',
+            $schema: 'http://json-schema.org/draft-07/schema'
+        };
+        let id = preId;
+        const messages = messagesToProcess;
+        if (messages.length > 1) {
+            schemaObj.oneOf = [];
+            schemaObj['$id'] = (0, utils_1.pascalCase)(`${preId}_Payload`);
+            for (const message of messages) {
+                if (!message.hasPayload()) {
+                    break;
+                }
+                const schema = modelina_1.AsyncAPIInputProcessor.convertToInternalSchema(message.payload());
+                const payloadId = message.id() ?? message.name();
+                if (typeof schema === 'boolean') {
+                    schemaObj.oneOf.push(schema);
+                }
+                else {
+                    const bindings = message.bindings();
+                    const statusCodesBindings = bindings?.get('http');
+                    const statusCodes = statusCodesBindings?.json()['statusCode'];
+                    if (statusCodesBindings && statusCodes) {
+                        schemaObj['x-modelina-has-status-codes'] = true;
+                        schema['x-modelina-status-codes'] = statusCodes;
+                    }
+                    schemaObj.oneOf.push({
+                        ...schema,
+                        $id: payloadId
+                    });
+                }
+            }
+        }
+        else if (messages.length === 1) {
+            const message = messages[0];
+            if (message.hasPayload()) {
+                const schema = modelina_1.AsyncAPIInputProcessor.convertToInternalSchema(message.payload());
+                if (typeof schema === 'boolean') {
+                    schemaObj = schema;
+                }
+                else {
+                    id =
+                        message.id() ??
+                            message.name() ??
+                            schema['x-modelgen-inferred-name'];
+                    if (id.includes('AnonymousSchema_')) {
+                        id = (0, utils_1.pascalCase)(`${preId}_Payload`);
+                    }
+                    schemaObj = {
+                        ...schemaObj,
+                        ...schema,
+                        $id: id
+                    };
+                }
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+        return {
+            schema: schemaObj,
+            schemaId: id ?? schemaObj.$id ?? (0, utils_1.pascalCase)(`${preId}_Payload`)
+        };
+    };
+    if (asyncapiDocument.allChannels().all().length > 0) {
+        for (const channel of asyncapiDocument.allChannels().all()) {
+            // Process operations
+            for (const operation of channel.operations().all()) {
+                const operationMessages = operation.messages().all();
+                const operationReply = operation.reply();
+                if (operationReply) {
+                    const operationReplyId = (0, utils_2.findReplyId)(operation, operationReply, channel);
+                    const operationReplySchema = processMessages(operationReply.messages().all(), operationReplyId);
+                    if (operationReplySchema) {
+                        operationPayloads[operationReplyId] = operationReplySchema;
+                    }
+                }
+                const operationId = (0, utils_2.findOperationId)(operation, channel);
+                const operationSchema = processMessages(operationMessages, operationId);
+                if (operationSchema) {
+                    operationPayloads[operationId] = operationSchema;
+                }
+            }
+            // Process channel messages
+            const channelSchema = processMessages(channel.messages().all(), (0, utils_2.findNameFromChannel)(channel));
+            if (channelSchema) {
+                channelPayloads[channel.id()] = channelSchema;
+            }
+        }
+    }
+    else {
+        // Handle case where there are no channels but there might be components
+        for (const message of asyncapiDocument.allMessages()) {
+            const schemaId = message.id() ?? message.name();
+            const schemaObj = processMessages([message], schemaId);
+            if (schemaObj) {
+                otherPayloads.push(schemaObj);
+            }
+        }
+    }
+    return {
+        channelPayloads,
+        operationPayloads,
+        otherPayloads: (0, utils_2.onlyUnique)(otherPayloads)
+    };
+}
+exports.processAsyncAPIPayloads = processAsyncAPIPayloads;

package/dist/codegen/inputs/asyncapi/generators/types.d.ts

@@ -0,0 +1,9 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { TypescriptTypesGeneratorInternal } from '../../../generators/typescript/types';
+import { GeneratedFile } from '../../../types';
+export interface TypesGeneratorResult {
+    result: string;
+    /** Generated files with path and content */
+    files: GeneratedFile[];
+}
+export declare function generateAsyncAPITypes(asyncapiDocument: AsyncAPIDocumentInterface, generator: TypescriptTypesGeneratorInternal): Promise<TypesGeneratorResult>;