@alagoni97/cli 0.72.1

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypescriptModels = exports.defaultTypeScriptModelsOptions = exports.zodTypescriptModelsGenerator = void 0;
+/* eslint-disable security/detect-object-injection */
+const modelina_1 = require("@asyncapi/modelina");
+const zod_1 = require("zod");
+const modelina_2 = require("../../modelina");
+const errors_1 = require("../../errors");
+const output_1 = require("../../output");
+exports.zodTypescriptModelsGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('models-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the models generator here](https://the-codegen-project.org/docs/generators/models)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. [Read more about the models generator here](https://the-codegen-project.org/docs/generators/models)'),
+    preset: zod_1.z
+        .literal('models')
+        .default('models')
+        .describe('Generates raw data models directly using Modelina, without any messaging-related logic. Use this preset for plain typed models from JSON Schema, OpenAPI components, or AsyncAPI message schemas. [Read more about the models generator here](https://the-codegen-project.org/docs/generators/models)'),
+    renderers: modelina_2.zodTypeScriptPresets,
+    options: modelina_2.zodTypeScriptOptions
+        .optional()
+        .describe('Modelina TypeScriptOptions used to configure the underlying TypeScript code generation (model type, enum representation, module system, constraints, etc.). [Read more about the models generator here](https://the-codegen-project.org/docs/generators/models)'),
+    outputPath: zod_1.z
+        .string()
+        .optional()
+        .default('src/__gen__/models')
+        .describe('The directory path where the generated models will be written. [Read more about the models generator here](https://the-codegen-project.org/docs/generators/models)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript')
+});
+exports.defaultTypeScriptModelsOptions = exports.zodTypescriptModelsGenerator.parse({});
+// Main generator function that orchestrates input processing and generation
+async function generateTypescriptModels(context) {
+    const { generator, asyncapiDocument, openapiDocument, jsonSchemaDocument } = context;
+    // Create generator with default options
+    const modelGenerator = new modelina_1.TypeScriptFileGenerator({
+        ...generator.options,
+        presets: generator.renderers
+    });
+    // Determine which document to use based on input type
+    const inputDocument = asyncapiDocument ?? openapiDocument ?? jsonSchemaDocument;
+    if (!inputDocument) {
+        throw new errors_1.CodegenError({
+            type: errors_1.ErrorType.MISSING_INPUT_DOCUMENT,
+            message: 'No input document provided for models generation',
+            help: `Ensure your configuration specifies 'inputPath' pointing to a valid AsyncAPI, OpenAPI, or JSON Schema document.\n\nFor more information: https://the-codegen-project.org/docs/configurations`
+        });
+    }
+    const result = await (0, output_1.generateModels)({
+        generator: modelGenerator,
+        input: inputDocument,
+        outputPath: generator.outputPath
+    });
+    return {
+        generator,
+        files: result.files
+    };
+}
+exports.generateTypescriptModels = generateTypescriptModels;

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

@@ -0,0 +1,37 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { GenericCodegenContext, ParameterRenderType } from '../../types';
+import { z } from 'zod';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export declare const zodTypescriptParametersGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"parameters">>;
+    outputPath: z.ZodDefault<z.ZodString>;
+    serializationType: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"json">>>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "parameters";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    serializationType: "json";
+}, {
+    preset?: "parameters" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    serializationType?: "json" | undefined;
+}>;
+export type TypescriptParametersGenerator = z.input<typeof zodTypescriptParametersGenerator>;
+export type TypescriptParametersGeneratorInternal = z.infer<typeof zodTypescriptParametersGenerator>;
+export declare const defaultTypeScriptParametersOptions: TypescriptParametersGeneratorInternal;
+export interface TypescriptParametersContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypescriptParametersGeneratorInternal;
+}
+export type TypeScriptParameterRenderType = ParameterRenderType<TypescriptParametersGeneratorInternal>;
+export declare function generateTypescriptParameters(context: TypescriptParametersContext): Promise<TypeScriptParameterRenderType>;

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypescriptParameters = exports.defaultTypeScriptParametersOptions = exports.zodTypescriptParametersGenerator = void 0;
+const zod_1 = require("zod");
+const parameters_1 = require("../../inputs/asyncapi/generators/parameters");
+const parameters_2 = require("../../inputs/openapi/generators/parameters");
+const errors_1 = require("../../errors");
+const output_1 = require("../../output");
+exports.zodTypescriptParametersGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('parameters-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the parameters generator here](https://the-codegen-project.org/docs/generators/parameters)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. [Read more about the parameters generator here](https://the-codegen-project.org/docs/generators/parameters)'),
+    preset: zod_1.z
+        .literal('parameters')
+        .default('parameters')
+        .describe('Generates typed channel/operation parameter models used to interpolate values into subjects, topics, and URL paths. [Read more about the parameters generator here](https://the-codegen-project.org/docs/generators/parameters)'),
+    outputPath: zod_1.z
+        .string()
+        .default('src/__gen__/parameters')
+        .describe('The directory path where the generated parameter models will be written. [Read more about the parameters generator here](https://the-codegen-project.org/docs/generators/parameters)'),
+    serializationType: zod_1.z
+        .literal('json')
+        .optional()
+        .default('json')
+        .describe('The serialization format used by the generated parameter models. Currently only "json" is supported. [Read more about the parameters generator here](https://the-codegen-project.org/docs/generators/parameters)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript')
+});
+exports.defaultTypeScriptParametersOptions = exports.zodTypescriptParametersGenerator.parse({});
+// Main generator function that orchestrates input processing and generation
+async function generateTypescriptParameters(context) {
+    const { asyncapiDocument, openapiDocument, inputType, generator } = context;
+    const channelModels = {};
+    const files = [];
+    let processedSchemaData;
+    let parameterGenerator;
+    // Process input based on type
+    switch (inputType) {
+        case 'asyncapi': {
+            if (!asyncapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'asyncapi',
+                    generatorPreset: 'parameters'
+                });
+            }
+            processedSchemaData = await (0, parameters_1.processAsyncAPIParameters)(asyncapiDocument);
+            parameterGenerator = (0, parameters_1.createAsyncAPIGenerator)();
+            break;
+        }
+        case 'openapi': {
+            if (!openapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'openapi',
+                    generatorPreset: 'parameters'
+                });
+            }
+            processedSchemaData = (0, parameters_2.processOpenAPIParameters)(openapiDocument);
+            parameterGenerator = (0, parameters_2.createOpenAPIGenerator)();
+            break;
+        }
+        default:
+            throw new Error(`Unsupported input type: ${inputType}`);
+    }
+    // Generate models for channel parameters
+    for (const [channelId, schemaData] of Object.entries(processedSchemaData.channelParameters)) {
+        if (schemaData) {
+            const result = await (0, output_1.generateModels)({
+                generator: parameterGenerator,
+                input: schemaData.schema,
+                outputPath: generator.outputPath
+            });
+            channelModels[channelId] =
+                result.models.length > 0 ? result.models[0] : undefined;
+            files.push(...result.files);
+        }
+        else {
+            channelModels[channelId] = undefined;
+        }
+    }
+    // Deduplicate files by path
+    const uniqueFiles = [];
+    const seenPaths = new Set();
+    for (const file of files) {
+        if (!seenPaths.has(file.path)) {
+            seenPaths.add(file.path);
+            uniqueFiles.push(file);
+        }
+    }
+    return {
+        channelModels,
+        generator,
+        files: uniqueFiles
+    };
+}
+exports.generateTypescriptParameters = generateTypescriptParameters;

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

@@ -0,0 +1,73 @@
+import { OutputModel } from '@asyncapi/modelina';
+import { GenericCodegenContext, PayloadRenderType } from '../../types';
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { ProcessedPayloadSchemaData } from '../../inputs/asyncapi/generators/payloads';
+import { z } from 'zod';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export declare const zodTypeScriptPayloadGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"payloads">>;
+    outputPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    serializationType: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"json">>>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+    enum: z.ZodDefault<z.ZodOptional<z.ZodEnum<["enum", "union"]>>>;
+    map: z.ZodDefault<z.ZodOptional<z.ZodEnum<["indexedObject", "map", "record"]>>>;
+    useForJavaScript: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeValidation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    rawPropertyNames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    map: "map" | "indexedObject" | "record";
+    enum: "enum" | "union";
+    rawPropertyNames: boolean;
+    preset: "payloads";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    serializationType: "json";
+    includeValidation: boolean;
+    useForJavaScript: boolean;
+}, {
+    map?: "map" | "indexedObject" | "record" | undefined;
+    enum?: "enum" | "union" | undefined;
+    rawPropertyNames?: boolean | undefined;
+    preset?: "payloads" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    serializationType?: "json" | undefined;
+    includeValidation?: boolean | undefined;
+    useForJavaScript?: boolean | undefined;
+}>;
+export type TypeScriptPayloadGenerator = z.input<typeof zodTypeScriptPayloadGenerator>;
+export type TypeScriptPayloadGeneratorInternal = z.infer<typeof zodTypeScriptPayloadGenerator>;
+export declare const defaultTypeScriptPayloadGenerator: TypeScriptPayloadGeneratorInternal;
+export interface TypeScriptPayloadContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypeScriptPayloadGeneratorInternal;
+}
+export type TypeScriptPayloadRenderType = PayloadRenderType<TypeScriptPayloadGeneratorInternal>;
+export interface ProcessedPayloadData {
+    channelModels: Record<string, {
+        messageModel: OutputModel;
+        messageType: string;
+    }>;
+    operationModels: Record<string, {
+        messageModel: OutputModel;
+        messageType: string;
+    }>;
+    otherModels: Array<{
+        messageModel: OutputModel;
+        messageType: string;
+    }>;
+}
+export declare function generateTypescriptPayloadsCore(processedData: ProcessedPayloadData, generator: TypeScriptPayloadGeneratorInternal): Promise<TypeScriptPayloadRenderType>;
+export declare function generateTypescriptPayloadsCoreFromSchemas({ context, processedSchemaData }: {
+    processedSchemaData: ProcessedPayloadSchemaData;
+    context: TypeScriptPayloadContext;
+}): Promise<TypeScriptPayloadRenderType>;
+export declare function generateTypescriptPayload(context: TypeScriptPayloadContext): Promise<TypeScriptPayloadRenderType>;

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

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypescriptPayload = exports.generateTypescriptPayloadsCoreFromSchemas = exports.generateTypescriptPayloadsCore = exports.defaultTypeScriptPayloadGenerator = exports.zodTypeScriptPayloadGenerator = void 0;
+/* eslint-disable security/detect-object-injection */
+const modelina_1 = require("@asyncapi/modelina");
+const payloads_1 = require("../../inputs/asyncapi/generators/payloads");
+const payloads_2 = require("../../inputs/openapi/generators/payloads");
+const zod_1 = require("zod");
+const utils_1 = require("./utils");
+const modelina_2 = require("@asyncapi/modelina");
+const presets_1 = require("../../modelina/presets");
+const errors_1 = require("../../errors");
+const output_1 = require("../../output");
+exports.zodTypeScriptPayloadGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('payloads-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    preset: zod_1.z
+        .literal('payloads')
+        .default('payloads')
+        .describe('Generates typed payload/message models that can be serialized into the wire format used for communication. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    outputPath: zod_1.z
+        .string()
+        .optional()
+        .default('src/__gen__/payloads')
+        .describe('The directory path where the generated payload models will be written. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    serializationType: zod_1.z
+        .literal('json')
+        .optional()
+        .default('json')
+        .describe('The serialization format used by the generated payload models. Currently only "json" is supported. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript'),
+    enum: zod_1.z
+        .enum(['enum', 'union'])
+        .optional()
+        .default('enum')
+        .describe('How payload enum types are rendered. By default ("enum") each is generated as a TypeScript enum, but "union" can be used to produce string/number union types instead. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    map: zod_1.z
+        .enum(['indexedObject', 'map', 'record'])
+        .optional()
+        .default('record')
+        .describe('How dictionary/map types are rendered: "record" for TypeScript Record<K, V> (default), "map" for the Map class, or "indexedObject" for index signatures. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    useForJavaScript: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When true (default), JavaScript restrictions are applied to the generated models so they remain valid when transpiled to JavaScript (for example, avoiding reserved keywords as identifiers). [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)'),
+    includeValidation: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When true (default), the generated payload models include built-in JSON Schema validation methods so incoming data can be validated at runtime. [Read more about payload validation here](https://the-codegen-project.org/docs/generators/payloads)'),
+    rawPropertyNames: zod_1.z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true, properties keep their raw names from the input schema (no normalization). Consumers will typically need to access them via obj["propertyName"] instead of obj.propertyName. [Read more about the payloads generator here](https://the-codegen-project.org/docs/generators/payloads)')
+});
+exports.defaultTypeScriptPayloadGenerator = exports.zodTypeScriptPayloadGenerator.parse({});
+// Core generator function that works with processed data
+async function generateTypescriptPayloadsCore(processedData, generator) {
+    // The models are already generated by the input processors,
+    // so we just need to return them in the expected format
+    return {
+        channelModels: processedData.channelModels,
+        operationModels: processedData.operationModels,
+        otherModels: processedData.otherModels,
+        generator,
+        files: []
+    };
+}
+exports.generateTypescriptPayloadsCore = generateTypescriptPayloadsCore;
+// Core generator function that works with processed schema data
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function generateTypescriptPayloadsCoreFromSchemas({ context, processedSchemaData }) {
+    const generator = context.generator;
+    const modelinaGenerator = new modelina_1.TypeScriptFileGenerator({
+        ...utils_1.defaultCodegenTypescriptModelinaOptions,
+        presets: [
+            modelina_2.TS_DESCRIPTION_PRESET,
+            {
+                preset: modelina_2.TS_COMMON_PRESET,
+                options: {
+                    marshalling: true
+                }
+            },
+            (0, presets_1.createValidationPreset)({
+                includeValidation: generator.includeValidation
+            }, context),
+            (0, presets_1.createUnionPreset)({
+                includeValidation: generator.includeValidation
+            }, context),
+            (0, presets_1.createPrimitivesPreset)({
+                includeValidation: generator.includeValidation
+            }, context)
+        ],
+        enumType: generator.enum,
+        mapType: generator.map,
+        rawPropertyNames: generator.rawPropertyNames,
+        useJavascriptReservedKeywords: generator.useForJavaScript
+    });
+    const channelModels = {};
+    const operationModels = {};
+    const otherModels = [];
+    const files = [];
+    // Generate models for channel payloads
+    for (const [channelId, schemaData] of Object.entries(processedSchemaData.channelPayloads)) {
+        if (schemaData) {
+            const result = await (0, output_1.generateModels)({
+                generator: modelinaGenerator,
+                input: schemaData.schema,
+                outputPath: generator.outputPath
+            });
+            const models = result.models;
+            files.push(...result.files);
+            if (models.length > 0) {
+                //Use first model as the root message model
+                const messageModel = models[0].model;
+                let messageType = messageModel.type;
+                if (!(messageModel instanceof modelina_1.ConstrainedObjectModel)) {
+                    messageType = messageModel.name;
+                }
+                channelModels[channelId] = {
+                    messageModel: models[0],
+                    messageType
+                };
+                // Add any additional models to otherModels
+                for (let i = 1; i < models.length; i++) {
+                    const additionalModel = models[i].model;
+                    otherModels.push({
+                        messageModel: models[i],
+                        messageType: additionalModel.type
+                    });
+                }
+            }
+        }
+    }
+    // Generate models for operation payloads
+    for (const [operationId, schemaData] of Object.entries(processedSchemaData.operationPayloads)) {
+        if (schemaData) {
+            const result = await (0, output_1.generateModels)({
+                generator: modelinaGenerator,
+                input: schemaData.schema,
+                outputPath: generator.outputPath
+            });
+            const models = result.models;
+            files.push(...result.files);
+            if (models.length > 0) {
+                //Use first model as the root message model
+                const messageModel = models[0].model;
+                let messageType = messageModel.type;
+                if (!(messageModel instanceof modelina_1.ConstrainedObjectModel)) {
+                    messageType = messageModel.name;
+                }
+                operationModels[operationId] = {
+                    messageModel: models[0],
+                    messageType
+                };
+                // Add any additional models to otherModels
+                for (let i = 1; i < models.length; i++) {
+                    const additionalModel = models[i].model;
+                    otherModels.push({
+                        messageModel: models[i],
+                        messageType: additionalModel.type
+                    });
+                }
+            }
+        }
+    }
+    // Generate models for other payloads
+    for (const schemaData of processedSchemaData.otherPayloads) {
+        const result = await (0, output_1.generateModels)({
+            generator: modelinaGenerator,
+            input: schemaData.schema,
+            outputPath: generator.outputPath
+        });
+        files.push(...result.files);
+        for (const model of result.models) {
+            const messageModel = model.model;
+            let messageType = messageModel.type;
+            if (!(messageModel instanceof modelina_1.ConstrainedObjectModel)) {
+                messageType = messageModel.name;
+            }
+            otherModels.push({
+                messageModel: model,
+                messageType
+            });
+        }
+    }
+    // Deduplicate files by path
+    const uniqueFiles = [];
+    const seenPaths = new Set();
+    for (const file of files) {
+        if (!seenPaths.has(file.path)) {
+            seenPaths.add(file.path);
+            uniqueFiles.push(file);
+        }
+    }
+    return {
+        channelModels,
+        operationModels,
+        otherModels,
+        generator,
+        files: uniqueFiles
+    };
+}
+exports.generateTypescriptPayloadsCoreFromSchemas = generateTypescriptPayloadsCoreFromSchemas;
+// Main generator function that orchestrates input processing and generation
+async function generateTypescriptPayload(context) {
+    const { asyncapiDocument, openapiDocument, inputType } = context;
+    let processedSchemaData;
+    // Process input based on type
+    switch (inputType) {
+        case 'asyncapi': {
+            if (!asyncapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'asyncapi',
+                    generatorPreset: 'payloads'
+                });
+            }
+            processedSchemaData = await (0, payloads_1.processAsyncAPIPayloads)(asyncapiDocument);
+            break;
+        }
+        case 'openapi': {
+            if (!openapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'openapi',
+                    generatorPreset: 'payloads'
+                });
+            }
+            processedSchemaData = (0, payloads_2.processOpenAPIPayloads)(openapiDocument);
+            break;
+        }
+        default:
+            throw new Error(`Unsupported input type: ${inputType}`);
+    }
+    // Generate final result using processed schema data
+    return generateTypescriptPayloadsCoreFromSchemas({
+        processedSchemaData,
+        context
+    });
+}
+exports.generateTypescriptPayload = generateTypescriptPayload;

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

@@ -0,0 +1,34 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { GenericCodegenContext, TypesRenderType } from '../../types';
+import { z } from 'zod';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export declare const zodTypescriptTypesGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"types">>;
+    outputPath: z.ZodDefault<z.ZodString>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "types";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+}, {
+    preset?: "types" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+}>;
+export type TypescriptTypesGenerator = z.input<typeof zodTypescriptTypesGenerator>;
+export type TypescriptTypesGeneratorInternal = z.infer<typeof zodTypescriptTypesGenerator>;
+export declare const defaultTypeScriptTypesOptions: TypescriptTypesGeneratorInternal;
+export interface TypescriptTypesContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    generator: TypescriptTypesGeneratorInternal;
+}
+export type TypeScriptTypesRenderType = TypesRenderType<TypescriptTypesGeneratorInternal>;
+export declare function generateTypescriptTypes(context: TypescriptTypesContext): Promise<TypeScriptTypesRenderType>;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypescriptTypes = exports.defaultTypeScriptTypesOptions = exports.zodTypescriptTypesGenerator = void 0;
+const zod_1 = require("zod");
+const types_1 = require("../../inputs/asyncapi/generators/types");
+const types_2 = require("../../inputs/openapi/generators/types");
+const errors_1 = require("../../errors");
+exports.zodTypescriptTypesGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('types-typescript')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the types generator here](https://the-codegen-project.org/docs/generators/types)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. [Read more about the types generator here](https://the-codegen-project.org/docs/generators/types)'),
+    preset: zod_1.z
+        .literal('types')
+        .default('types')
+        .describe('Generates simple type aliases and enum definitions derived from the input document. [Read more about the types generator here](https://the-codegen-project.org/docs/generators/types)'),
+    outputPath: zod_1.z
+        .string()
+        .default('src/__gen__')
+        .describe('The directory path where the generated type definitions will be written. [Read more about the types generator here](https://the-codegen-project.org/docs/generators/types)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript')
+});
+exports.defaultTypeScriptTypesOptions = exports.zodTypescriptTypesGenerator.parse({});
+async function generateTypescriptTypes(context) {
+    const { asyncapiDocument, openapiDocument, inputType, generator } = context;
+    let result;
+    let files = [];
+    switch (inputType) {
+        case 'asyncapi':
+            if (!asyncapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'asyncapi',
+                    generatorPreset: 'types'
+                });
+            }
+            {
+                const asyncAPIResult = await (0, types_1.generateAsyncAPITypes)(asyncapiDocument, generator);
+                result = asyncAPIResult.result;
+                files = asyncAPIResult.files;
+            }
+            break;
+        case 'openapi':
+            if (!openapiDocument) {
+                throw (0, errors_1.createMissingInputDocumentError)({
+                    expectedType: 'openapi',
+                    generatorPreset: 'types'
+                });
+            }
+            {
+                const openAPIResult = await (0, types_2.generateOpenAPITypes)(openapiDocument, generator);
+                result = openAPIResult.result;
+                files = openAPIResult.files;
+            }
+            break;
+        default:
+            throw new Error(`Unsupported input type: ${inputType}`);
+    }
+    return {
+        result,
+        generator,
+        files
+    };
+}
+exports.generateTypescriptTypes = generateTypescriptTypes;