@alagoni97/cli 0.72.1

package/dist/codegen/errors.d.ts

@@ -0,0 +1,111 @@
+export declare enum ErrorType {
+    CONFIG_NOT_FOUND = "CONFIG_NOT_FOUND",
+    CONFIG_PARSE_ERROR = "CONFIG_PARSE_ERROR",
+    CONFIG_VALIDATION_ERROR = "CONFIG_VALIDATION_ERROR",
+    INVALID_PRESET = "INVALID_PRESET",
+    INVALID_INPUT_TYPE = "INVALID_INPUT_TYPE",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    INPUT_DOCUMENT_ERROR = "INPUT_DOCUMENT_ERROR",
+    GENERATOR_ERROR = "GENERATOR_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    UNSUPPORTED_LANGUAGE = "UNSUPPORTED_LANGUAGE",
+    MISSING_INPUT_DOCUMENT = "MISSING_INPUT_DOCUMENT",
+    MISSING_PAYLOAD = "MISSING_PAYLOAD",
+    MISSING_PARAMETER = "MISSING_PARAMETER",
+    CIRCULAR_DEPENDENCY = "CIRCULAR_DEPENDENCY",
+    DUPLICATE_GENERATOR_ID = "DUPLICATE_GENERATOR_ID",
+    UNSUPPORTED_PRESET_FOR_INPUT = "UNSUPPORTED_PRESET_FOR_INPUT"
+}
+export interface CodegenErrorDetails {
+    type: ErrorType;
+    message: string;
+    help?: string;
+    details?: string;
+}
+export declare class CodegenError extends Error {
+    readonly type: ErrorType;
+    readonly help?: string;
+    readonly details?: string;
+    constructor({ type, message, help, details }: CodegenErrorDetails);
+    /**
+     * Format the error message for display to users
+     * @param useColors Whether to use colored output
+     */
+    format(useColors?: boolean): string;
+}
+/**
+ * Helper functions to create specific error types
+ */
+export declare function createConfigNotFoundError(options?: {
+    filePath?: string;
+    searchLocations?: string[];
+}): CodegenError;
+export declare function createConfigParseError(options: {
+    filePath: string;
+    originalError: Error;
+}): CodegenError;
+export declare function createInvalidPresetError(options: {
+    preset: string;
+    language: string;
+}): CodegenError;
+export declare function createInvalidInputTypeError(options: {
+    inputType: string;
+}): CodegenError;
+export declare function createMissingRequiredFieldError(options: {
+    field: string;
+    location?: string;
+}): CodegenError;
+export declare function createConfigValidationError(options: {
+    validationErrors: string[];
+}): CodegenError;
+export declare function createInputDocumentError(options: {
+    inputPath: string;
+    inputType: string;
+    errorMessage: string;
+}): CodegenError;
+export declare function createRemoteFetchError(options: {
+    url: string;
+    status?: number;
+    statusText?: string;
+    cause?: unknown;
+    reason?: 'timeout' | 'network' | 'http';
+}): CodegenError;
+export declare function createGeneratorError(options: {
+    generatorId: string;
+    originalError: Error;
+}): CodegenError;
+export declare function createUnsupportedLanguageError(options: {
+    preset: string;
+    language: string;
+}): CodegenError;
+export declare function createMissingInputDocumentError(options: {
+    expectedType: 'asyncapi' | 'openapi' | 'jsonschema';
+    generatorPreset?: string;
+}): CodegenError;
+export declare function createMissingPayloadError(options: {
+    channelOrOperation: string;
+    protocol?: string;
+}): CodegenError;
+export declare function createMissingParameterError(options: {
+    channelOrOperation: string;
+    protocol?: string;
+}): CodegenError;
+export declare function createCircularDependencyError(options?: {
+    generatorIds?: string[];
+}): CodegenError;
+export declare function createDuplicateGeneratorIdError(options: {
+    duplicateIds: string[];
+}): CodegenError;
+export declare function createUnsupportedPresetForInputError(options: {
+    preset: string;
+    inputType: string;
+    supportedPresets: string[];
+}): CodegenError;
+export declare function createMissingDependencyOutputError(options: {
+    generatorPreset: string;
+    dependencyName: string;
+}): CodegenError;
+/**
+ * Parse Zod validation errors and convert them to user-friendly messages
+ */
+export declare function parseZodErrors(zodError: any): string[];

package/dist/codegen/errors.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseZodErrors = exports.createMissingDependencyOutputError = exports.createUnsupportedPresetForInputError = exports.createDuplicateGeneratorIdError = exports.createCircularDependencyError = exports.createMissingParameterError = exports.createMissingPayloadError = exports.createMissingInputDocumentError = exports.createUnsupportedLanguageError = exports.createGeneratorError = exports.createRemoteFetchError = exports.createInputDocumentError = exports.createConfigValidationError = exports.createMissingRequiredFieldError = exports.createInvalidInputTypeError = exports.createInvalidPresetError = exports.createConfigParseError = exports.createConfigNotFoundError = exports.CodegenError = exports.ErrorType = void 0;
+/**
+ * Custom error types for better error handling and user-friendly messages
+ */
+const picocolors_1 = __importDefault(require("picocolors"));
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["CONFIG_NOT_FOUND"] = "CONFIG_NOT_FOUND";
+    ErrorType["CONFIG_PARSE_ERROR"] = "CONFIG_PARSE_ERROR";
+    ErrorType["CONFIG_VALIDATION_ERROR"] = "CONFIG_VALIDATION_ERROR";
+    ErrorType["INVALID_PRESET"] = "INVALID_PRESET";
+    ErrorType["INVALID_INPUT_TYPE"] = "INVALID_INPUT_TYPE";
+    ErrorType["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
+    ErrorType["INPUT_DOCUMENT_ERROR"] = "INPUT_DOCUMENT_ERROR";
+    ErrorType["GENERATOR_ERROR"] = "GENERATOR_ERROR";
+    ErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+    ErrorType["UNSUPPORTED_LANGUAGE"] = "UNSUPPORTED_LANGUAGE";
+    ErrorType["MISSING_INPUT_DOCUMENT"] = "MISSING_INPUT_DOCUMENT";
+    ErrorType["MISSING_PAYLOAD"] = "MISSING_PAYLOAD";
+    ErrorType["MISSING_PARAMETER"] = "MISSING_PARAMETER";
+    ErrorType["CIRCULAR_DEPENDENCY"] = "CIRCULAR_DEPENDENCY";
+    ErrorType["DUPLICATE_GENERATOR_ID"] = "DUPLICATE_GENERATOR_ID";
+    ErrorType["UNSUPPORTED_PRESET_FOR_INPUT"] = "UNSUPPORTED_PRESET_FOR_INPUT";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+class CodegenError extends Error {
+    type;
+    help;
+    details;
+    constructor({ type, message, help, details }) {
+        super(message);
+        this.name = 'CodegenError';
+        this.type = type;
+        this.help = help;
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, CodegenError);
+        }
+    }
+    /**
+     * Format the error message for display to users
+     * @param useColors Whether to use colored output
+     */
+    format(useColors = true) {
+        const c = useColors
+            ? picocolors_1.default
+            : {
+                red: (s) => s,
+                yellow: (s) => s,
+                cyan: (s) => s,
+                dim: (s) => s,
+                bold: (s) => s
+            };
+        let output = `\n${c.red(c.bold('Error:'))} ${this.message}`;
+        if (this.details) {
+            output += `\n\n${c.yellow('Details:')}\n${c.dim(this.details)}`;
+        }
+        if (this.help) {
+            output += `\n\n${c.cyan('How to fix:')}\n${this.help}`;
+        }
+        return output;
+    }
+}
+exports.CodegenError = CodegenError;
+/**
+ * Helper functions to create specific error types
+ */
+function createConfigNotFoundError(options) {
+    const { filePath, searchLocations } = options ?? {};
+    if (filePath) {
+        return new CodegenError({
+            type: ErrorType.CONFIG_NOT_FOUND,
+            message: `Configuration file not found at: ${filePath}`,
+            help: `Please check that the file exists and the path is correct.\nYou can create a configuration file using: codegen init`
+        });
+    }
+    const locations = searchLocations?.map((loc) => `  - ${loc}`).join('\n') || '';
+    return new CodegenError({
+        type: ErrorType.CONFIG_NOT_FOUND,
+        message: 'No configuration file found in the current directory',
+        details: `Searched in the following locations:\n${locations}`,
+        help: `Create a configuration file using: codegen init\nOr specify a configuration file path: codegen generate <path-to-config>`
+    });
+}
+exports.createConfigNotFoundError = createConfigNotFoundError;
+function createConfigParseError(options) {
+    const { filePath, originalError } = options;
+    return new CodegenError({
+        type: ErrorType.CONFIG_PARSE_ERROR,
+        message: `Failed to parse configuration file: ${filePath}`,
+        details: originalError.message,
+        help: `Check that your configuration file is valid JSON, YAML, or JavaScript.\nMake sure there are no syntax errors in the file.`
+    });
+}
+exports.createConfigParseError = createConfigParseError;
+function createInvalidPresetError(options) {
+    const { preset, language } = options;
+    const validPresets = [
+        'payloads',
+        'parameters',
+        'headers',
+        'types',
+        'channels',
+        'client',
+        'models',
+        'custom'
+    ];
+    const presetList = validPresets.map((p) => `  - ${p}`).join('\n');
+    return new CodegenError({
+        type: ErrorType.INVALID_PRESET,
+        message: `Invalid preset '${preset}' for language '${language}'`,
+        details: `Valid presets are:\n${presetList}`,
+        help: `Update your configuration to use a valid preset.\nFor more information, visit: https://the-codegen-project.org/docs/generators`
+    });
+}
+exports.createInvalidPresetError = createInvalidPresetError;
+function createInvalidInputTypeError(options) {
+    const { inputType } = options;
+    const validTypes = ['asyncapi', 'openapi', 'jsonschema'];
+    const typeList = validTypes.map((t) => `  - ${t}`).join('\n');
+    return new CodegenError({
+        type: ErrorType.INVALID_INPUT_TYPE,
+        message: `Invalid input type '${inputType}'`,
+        details: `Valid input types are:\n${typeList}`,
+        help: `Update your configuration to use a valid inputType.\nFor more information, visit: https://the-codegen-project.org/docs/category/inputs`
+    });
+}
+exports.createInvalidInputTypeError = createInvalidInputTypeError;
+function createMissingRequiredFieldError(options) {
+    const { field, location } = options;
+    const locationSuffix = location ? ` at "${location}"` : '';
+    return new CodegenError({
+        type: ErrorType.MISSING_REQUIRED_FIELD,
+        message: `Missing required field: ${field}${locationSuffix}`,
+        help: `Add the required '${field}' field to your configuration file.\nFor more information, visit: https://the-codegen-project.org/docs/configurations/`
+    });
+}
+exports.createMissingRequiredFieldError = createMissingRequiredFieldError;
+function createConfigValidationError(options) {
+    const { validationErrors } = options;
+    return new CodegenError({
+        type: ErrorType.CONFIG_VALIDATION_ERROR,
+        message: 'Configuration validation failed',
+        details: validationErrors.join('\n'),
+        help: `Review and fix the validation errors in your configuration file.\nFor more information, visit: https://the-codegen-project.org/docs/configurations/`
+    });
+}
+exports.createConfigValidationError = createConfigValidationError;
+function detectFormatHint(inputPath) {
+    if (inputPath.endsWith('.json')) {
+        return 'JSON';
+    }
+    if (inputPath.endsWith('.yaml') || inputPath.endsWith('.yml')) {
+        return 'YAML';
+    }
+    return 'JSON or YAML';
+}
+function createInputDocumentError(options) {
+    const { inputPath, inputType, errorMessage } = options;
+    const isUrl = inputPath.startsWith('http://') || inputPath.startsWith('https://');
+    const formatHint = detectFormatHint(inputPath);
+    const sourceHelp = isUrl
+        ? `Check that the URL is reachable and returns a valid ${formatHint} document.`
+        : `Check that the input file exists and is a valid ${formatHint} file.`;
+    return new CodegenError({
+        type: ErrorType.INPUT_DOCUMENT_ERROR,
+        message: `Failed to load ${inputType} document: ${inputPath}`,
+        details: errorMessage,
+        help: `${sourceHelp}\nEnsure the document conforms to the ${inputType} specification.`
+    });
+}
+exports.createInputDocumentError = createInputDocumentError;
+/**
+ * Build a typed error for a failed remote fetch. Help text is tailored
+ * to the HTTP status code (401/403 → auth, 404 → URL, 429 → rate-limit,
+ * timeout → timeout, network → connectivity, other → generic).
+ */
+function remoteFetchHelp(url, reason, status, cause) {
+    if (reason === 'timeout') {
+        return 'The request timed out. Increase the timeout, retry, or check that the host is reachable.';
+    }
+    if (status === 401 || status === 403) {
+        return `Authentication or authorization failed for ${url}. Check the 'auth' field in your configuration (token, header name, header value).`;
+    }
+    if (status === 404) {
+        return `The URL ${url} returned 404. Verify the URL is correct and the resource exists.`;
+    }
+    if (status === 429) {
+        return `The server is rate-limiting requests to ${url}. Retry later or reduce the request rate.`;
+    }
+    if (status && status >= 500) {
+        return `The server returned a ${status} error for ${url}. The remote service may be temporarily unavailable; retry later.`;
+    }
+    if (reason === 'network' || (!status && cause)) {
+        return `Could not reach ${url}. Check your network connection, DNS, and any firewall/proxy settings.`;
+    }
+    return `Could not fetch ${url}.`;
+}
+function formatStatusPart(status, statusText) {
+    if (!status) {
+        return '';
+    }
+    const trailing = statusText ? ` ${statusText}` : '';
+    return ` (HTTP ${status}${trailing})`;
+}
+function stringifyCause(cause) {
+    if (cause instanceof Error) {
+        return cause.message;
+    }
+    if (cause === undefined) {
+        return '';
+    }
+    return String(cause);
+}
+function createRemoteFetchError(options) {
+    const { url, status, statusText, cause, reason } = options;
+    const help = remoteFetchHelp(url, reason, status, cause);
+    const statusPart = formatStatusPart(status, statusText);
+    const causePart = stringifyCause(cause);
+    return new CodegenError({
+        type: ErrorType.INPUT_DOCUMENT_ERROR,
+        message: `Failed to fetch remote document from ${url}${statusPart}`,
+        details: causePart || undefined,
+        help
+    });
+}
+exports.createRemoteFetchError = createRemoteFetchError;
+function createGeneratorError(options) {
+    const { generatorId, originalError } = options;
+    return new CodegenError({
+        type: ErrorType.GENERATOR_ERROR,
+        message: `Generator '${generatorId}' failed`,
+        details: originalError.message,
+        help: `Check the generator configuration and input document.\nIf the issue persists, please report it at: https://github.com/the-codegen-project/cli/issues`
+    });
+}
+exports.createGeneratorError = createGeneratorError;
+function createUnsupportedLanguageError(options) {
+    const { preset, language } = options;
+    return new CodegenError({
+        type: ErrorType.UNSUPPORTED_LANGUAGE,
+        message: `Language '${language}' is not supported for the '${preset}' preset`,
+        details: `Currently only 'typescript' is supported.`,
+        help: `Change the 'language' field in your configuration to 'typescript'.\nFor more information: https://the-codegen-project.org/docs/configurations`
+    });
+}
+exports.createUnsupportedLanguageError = createUnsupportedLanguageError;
+function createMissingInputDocumentError(options) {
+    const { expectedType, generatorPreset } = options;
+    const presetContext = generatorPreset
+        ? ` for the '${generatorPreset}' generator`
+        : '';
+    return new CodegenError({
+        type: ErrorType.MISSING_INPUT_DOCUMENT,
+        message: `Expected ${expectedType} document${presetContext}, but none was provided`,
+        help: `1. Ensure your configuration has 'inputType: "${expectedType}"'\n2. Verify 'inputPath' points to a valid ${expectedType} document\n3. Check the document exists and is readable\n\nFor more information: https://the-codegen-project.org/docs/inputs/${expectedType}`
+    });
+}
+exports.createMissingInputDocumentError = createMissingInputDocumentError;
+function createMissingPayloadError(options) {
+    const { channelOrOperation, protocol } = options;
+    const protocolContext = protocol ? ` for ${protocol}` : '';
+    return new CodegenError({
+        type: ErrorType.MISSING_PAYLOAD,
+        message: `Could not find payload for '${channelOrOperation}'${protocolContext}`,
+        help: `1. Ensure the 'payloads' generator is configured before 'channels'\n2. Check that your spec defines message payloads for this channel\n3. Verify the channel/operation name matches the spec\n\nFor more information: https://the-codegen-project.org/docs/generators/channels`
+    });
+}
+exports.createMissingPayloadError = createMissingPayloadError;
+function createMissingParameterError(options) {
+    const { channelOrOperation, protocol } = options;
+    const protocolContext = protocol ? ` for ${protocol}` : '';
+    return new CodegenError({
+        type: ErrorType.MISSING_PARAMETER,
+        message: `Could not find parameter for '${channelOrOperation}'${protocolContext}`,
+        help: `1. Ensure the 'parameters' generator is configured before 'channels'\n2. Check that your spec defines parameters for this channel\n3. Verify the channel/operation name matches the spec\n\nFor more information: https://the-codegen-project.org/docs/generators/channels`
+    });
+}
+exports.createMissingParameterError = createMissingParameterError;
+function createCircularDependencyError(options) {
+    const generatorIds = options?.generatorIds;
+    const idsContext = generatorIds?.length
+        ? `\nInvolved generators: ${generatorIds.join(', ')}`
+        : '';
+    return new CodegenError({
+        type: ErrorType.CIRCULAR_DEPENDENCY,
+        message: `Circular dependency detected in generator configuration${idsContext}`,
+        help: `Review the 'dependencies' field in your generators to remove circular references.\nGenerators are executed in dependency order - ensure there's no A->B->A cycle.\n\nFor more information: https://the-codegen-project.org/docs/configurations`
+    });
+}
+exports.createCircularDependencyError = createCircularDependencyError;
+function createDuplicateGeneratorIdError(options) {
+    const { duplicateIds } = options;
+    return new CodegenError({
+        type: ErrorType.DUPLICATE_GENERATOR_ID,
+        message: `Duplicate generator IDs found: ${duplicateIds.join(', ')}`,
+        help: `Each generator must have a unique 'id'. Either:\n1. Remove duplicate generators\n2. Give each generator a unique 'id' field\n\nFor more information: https://the-codegen-project.org/docs/configurations`
+    });
+}
+exports.createDuplicateGeneratorIdError = createDuplicateGeneratorIdError;
+function createUnsupportedPresetForInputError(options) {
+    const { preset, inputType, supportedPresets } = options;
+    return new CodegenError({
+        type: ErrorType.UNSUPPORTED_PRESET_FOR_INPUT,
+        message: `Preset '${preset}' is not supported with '${inputType}' input`,
+        details: `Supported presets for ${inputType}: ${supportedPresets.join(', ')}`,
+        help: `Change your generator to use a supported preset, or change your input type.\n\nFor more information: https://the-codegen-project.org/docs/generators`
+    });
+}
+exports.createUnsupportedPresetForInputError = createUnsupportedPresetForInputError;
+function createMissingDependencyOutputError(options) {
+    const { generatorPreset, dependencyName } = options;
+    return new CodegenError({
+        type: ErrorType.GENERATOR_ERROR,
+        message: `Internal error: Missing dependency output '${dependencyName}' for '${generatorPreset}' generator`,
+        help: `This is likely a bug. Please report it at: https://github.com/the-codegen-project/cli/issues`
+    });
+}
+exports.createMissingDependencyOutputError = createMissingDependencyOutputError;
+/**
+ * Parse Zod validation errors and convert them to user-friendly messages
+ */
+function parseZodErrors(zodError) {
+    const errors = [];
+    if (zodError.issues) {
+        for (const error of zodError.issues) {
+            const path = error.path.join('.');
+            const message = error.message;
+            // Handle specific error types
+            if (error.code === 'invalid_union_discriminator') {
+                const expected = error.options?.join("' | '") || '';
+                errors.push(`Invalid value at "${path}". Expected: '${expected}'`);
+            }
+            else if (error.code === 'invalid_type') {
+                errors.push(`Invalid type at "${path}". Expected ${error.expected}, got ${error.received}`);
+            }
+            else if (error.code === 'invalid_literal') {
+                errors.push(`Invalid value at "${path}". Expected: '${error.expected}'`);
+            }
+            else {
+                errors.push(`${message} at "${path}"`);
+            }
+        }
+    }
+    return errors;
+}
+exports.parseZodErrors = parseZodErrors;

package/dist/codegen/generators/generic/custom.d.ts

@@ -0,0 +1,75 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import { GenericCodegenContext } from '../../types';
+import { z } from 'zod';
+import { OpenAPIV3, OpenAPIV2, OpenAPIV3_1 } from 'openapi-types';
+import { JsonSchemaDocument } from '../../inputs/jsonschema';
+export interface CustomContext extends GenericCodegenContext {
+    inputType: 'asyncapi' | 'openapi' | 'jsonschema';
+    asyncapiDocument?: AsyncAPIDocumentInterface;
+    openapiDocument?: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+    jsonSchemaDocument?: JsonSchemaDocument;
+    generator: CustomGenerator;
+}
+export declare const zodCustomGenerator: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    preset: z.ZodDefault<z.ZodLiteral<"custom">>;
+    options: z.ZodDefault<z.ZodOptional<z.ZodAny>>;
+    outputPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    language: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"typescript">>>;
+    renderFunction: z.ZodDefault<z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodDefault<z.ZodObject<{
+        inputType: z.ZodDefault<z.ZodEnum<["asyncapi", "openapi", "jsonschema"]>>;
+        asyncapiDocument: z.ZodAny;
+        openapiDocument: z.ZodAny;
+        jsonSchemaDocument: z.ZodAny;
+        generator: z.ZodAny;
+        dependencyOutputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        inputType: "asyncapi" | "openapi" | "jsonschema";
+        dependencyOutputs: Record<string, any>;
+        generator?: any;
+        asyncapiDocument?: any;
+        openapiDocument?: any;
+        jsonSchemaDocument?: any;
+    }, {
+        inputType?: "asyncapi" | "openapi" | "jsonschema" | undefined;
+        generator?: any;
+        asyncapiDocument?: any;
+        openapiDocument?: any;
+        dependencyOutputs?: Record<string, any> | undefined;
+        jsonSchemaDocument?: any;
+    }>>, z.ZodDefault<z.ZodOptional<z.ZodAny>>], z.ZodUnknown>, z.ZodAny>>>;
+}, "strip", z.ZodTypeAny, {
+    preset: "custom";
+    id: string;
+    dependencies: string[];
+    language: "typescript";
+    outputPath: string;
+    renderFunction: (args_0: {
+        inputType?: "asyncapi" | "openapi" | "jsonschema" | undefined;
+        generator?: any;
+        asyncapiDocument?: any;
+        openapiDocument?: any;
+        dependencyOutputs?: Record<string, any> | undefined;
+        jsonSchemaDocument?: any;
+    } | undefined, args_1: any, ...args_2: unknown[]) => any;
+    options?: any;
+}, {
+    options?: any;
+    preset?: "custom" | undefined;
+    id?: string | undefined;
+    dependencies?: string[] | undefined;
+    language?: "typescript" | undefined;
+    outputPath?: string | undefined;
+    renderFunction?: ((args_0: {
+        inputType: "asyncapi" | "openapi" | "jsonschema";
+        dependencyOutputs: Record<string, any>;
+        generator?: any;
+        asyncapiDocument?: any;
+        openapiDocument?: any;
+        jsonSchemaDocument?: any;
+    }, args_1: any, ...args_2: unknown[]) => any) | undefined;
+}>;
+export type CustomGenerator = z.input<typeof zodCustomGenerator>;
+export type CustomGeneratorInternal = z.infer<typeof zodCustomGenerator>;
+export declare const defaultCustomGenerator: CustomGeneratorInternal;

package/dist/codegen/generators/generic/custom.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCustomGenerator = exports.zodCustomGenerator = void 0;
+const zod_1 = require("zod");
+exports.zodCustomGenerator = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .optional()
+        .default('custom')
+        .describe('Unique identifier for this generator instance. Used by other generators to reference this one as a dependency. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+    dependencies: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .default([])
+        .describe('The list of other generator IDs that this generator depends on. Outputs from these generators are passed to renderFunction via dependencyOutputs. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+    preset: zod_1.z
+        .literal('custom')
+        .default('custom')
+        .describe('Lets you write a custom render function that produces arbitrary code from the parsed input document and the outputs of other generators. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+    options: zod_1.z
+        .any()
+        .optional()
+        .default({})
+        .describe('Arbitrary user-defined options that are forwarded to the renderFunction as its second argument. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+    outputPath: zod_1.z
+        .string()
+        .optional()
+        .default('custom')
+        .describe('The directory path where files written by the custom generator will be placed. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+    language: zod_1.z.literal('typescript').optional().default('typescript'),
+    renderFunction: zod_1.z
+        .function()
+        .args(zod_1.z
+        .object({
+        inputType: zod_1.z
+            .enum(['asyncapi', 'openapi', 'jsonschema'])
+            .default('asyncapi')
+            .describe('The type of input document being processed. [Read more about supported inputs here](https://the-codegen-project.org/docs/configurations)'),
+        asyncapiDocument: zod_1.z
+            .any()
+            .describe('The parsed AsyncAPI document (AsyncAPIDocumentInterface from @asyncapi/parser) when inputType is "asyncapi". [Read more about AsyncAPI input here](https://the-codegen-project.org/docs/inputs/asyncapi)'),
+        openapiDocument: zod_1.z
+            .any()
+            .describe('The parsed OpenAPI document (one of OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document from openapi-types) when inputType is "openapi". [Read more about OpenAPI input here](https://the-codegen-project.org/docs/inputs/openapi)'),
+        jsonSchemaDocument: zod_1.z
+            .any()
+            .describe('The parsed JSON Schema document when inputType is "jsonschema". [Read more about JSON Schema input here](https://the-codegen-project.org/docs/inputs/jsonschema)'),
+        generator: zod_1.z
+            .any()
+            .describe('The fully resolved configuration object for this custom generator instance. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)'),
+        dependencyOutputs: zod_1.z
+            .record(zod_1.z.any())
+            .default({})
+            .describe('A map of generator ID to render result for each generator listed in dependencies. Use this to access models, channels, etc. produced by other generators. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)')
+    })
+        .default({}), zod_1.z
+        .any()
+        .optional()
+        .describe('The user-defined options passed in via the "options" field of this generator configuration. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)')
+        .default({}))
+        .returns(zod_1.z.any())
+        .optional()
+        .default(() => { })
+        .describe('The render function executed by the custom generator. Receives the parsed input document and the outputs of dependency generators, and is responsible for producing custom code. [Read more about the custom generator here](https://the-codegen-project.org/docs/generators/custom)')
+});
+exports.defaultCustomGenerator = exports.zodCustomGenerator.parse({});

package/dist/codegen/generators/index.d.ts

@@ -0,0 +1,14 @@
+export { TypescriptParametersGenerator, generateTypescriptParameters, defaultTypeScriptParametersOptions, TypeScriptPayloadGenerator, generateTypescriptPayload, defaultTypeScriptPayloadGenerator, TypeScriptChannelsGenerator, generateTypeScriptChannels, defaultTypeScriptChannelsGenerator, TypeScriptClientGenerator, defaultTypeScriptClientGenerator, generateTypeScriptClient, TypeScriptChannelsContext, TypeScriptClientContext, TypeScriptPayloadContext, TypescriptParametersContext, TypeScriptPayloadGeneratorInternal, TypeScriptChannelsGeneratorInternal, TypeScriptClientGeneratorInternal, TypescriptParametersGeneratorInternal, TypeScriptParameterRenderType, TypescriptHeadersContext, TypescriptHeadersGenerator, defaultTypeScriptHeadersOptions, generateTypescriptHeaders, TypescriptHeadersGeneratorInternal, TypescriptTypesContext, TypescriptTypesGenerator, TypescriptTypesGeneratorInternal, defaultTypeScriptTypesOptions, generateTypescriptTypes, ChannelFunctionTypes } from './typescript';
+export { defaultCustomGenerator, CustomGenerator, CustomGeneratorInternal, CustomContext } from './generic/custom';
+import { GenerationResult, RunGeneratorContext } from '../types';
+/**
+ * Function that runs the given generator context ensuring the generators are rendered in the correct order.
+ */
+export declare function runGenerators(context: RunGeneratorContext): Promise<GenerationResult>;
+/**
+ * Load the configuration and run the generator
+ *
+ * @param configFileOrContext Either a config file path or a pre-realized RunGeneratorContext
+ * @returns Generation result with file tracking information
+ */
+export declare function generateWithConfig(configFileOrContext: string | undefined | RunGeneratorContext): Promise<GenerationResult>;

package/dist/codegen/generators/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWithConfig = exports.runGenerators = exports.defaultCustomGenerator = exports.ChannelFunctionTypes = exports.generateTypescriptTypes = exports.defaultTypeScriptTypesOptions = exports.generateTypescriptHeaders = exports.defaultTypeScriptHeadersOptions = exports.generateTypeScriptClient = exports.defaultTypeScriptClientGenerator = exports.defaultTypeScriptChannelsGenerator = exports.generateTypeScriptChannels = exports.defaultTypeScriptPayloadGenerator = exports.generateTypescriptPayload = exports.defaultTypeScriptParametersOptions = exports.generateTypescriptParameters = void 0;
+var typescript_1 = require("./typescript");
+Object.defineProperty(exports, "generateTypescriptParameters", { enumerable: true, get: function () { return typescript_1.generateTypescriptParameters; } });
+Object.defineProperty(exports, "defaultTypeScriptParametersOptions", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptParametersOptions; } });
+Object.defineProperty(exports, "generateTypescriptPayload", { enumerable: true, get: function () { return typescript_1.generateTypescriptPayload; } });
+Object.defineProperty(exports, "defaultTypeScriptPayloadGenerator", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptPayloadGenerator; } });
+Object.defineProperty(exports, "generateTypeScriptChannels", { enumerable: true, get: function () { return typescript_1.generateTypeScriptChannels; } });
+Object.defineProperty(exports, "defaultTypeScriptChannelsGenerator", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptChannelsGenerator; } });
+Object.defineProperty(exports, "defaultTypeScriptClientGenerator", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptClientGenerator; } });
+Object.defineProperty(exports, "generateTypeScriptClient", { enumerable: true, get: function () { return typescript_1.generateTypeScriptClient; } });
+Object.defineProperty(exports, "defaultTypeScriptHeadersOptions", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptHeadersOptions; } });
+Object.defineProperty(exports, "generateTypescriptHeaders", { enumerable: true, get: function () { return typescript_1.generateTypescriptHeaders; } });
+Object.defineProperty(exports, "defaultTypeScriptTypesOptions", { enumerable: true, get: function () { return typescript_1.defaultTypeScriptTypesOptions; } });
+Object.defineProperty(exports, "generateTypescriptTypes", { enumerable: true, get: function () { return typescript_1.generateTypescriptTypes; } });
+Object.defineProperty(exports, "ChannelFunctionTypes", { enumerable: true, get: function () { return typescript_1.ChannelFunctionTypes; } });
+var custom_1 = require("./generic/custom");
+Object.defineProperty(exports, "defaultCustomGenerator", { enumerable: true, get: function () { return custom_1.defaultCustomGenerator; } });
+const renderer_1 = require("../renderer");
+const configurations_1 = require("../configurations");
+/**
+ * Function that runs the given generator context ensuring the generators are rendered in the correct order.
+ */
+async function runGenerators(context) {
+    const graph = (0, renderer_1.determineRenderGraph)(context);
+    return (0, renderer_1.renderGraph)(context, graph);
+}
+exports.runGenerators = runGenerators;
+/**
+ * Load the configuration and run the generator
+ *
+ * @param configFileOrContext Either a config file path or a pre-realized RunGeneratorContext
+ * @returns Generation result with file tracking information
+ */
+async function generateWithConfig(configFileOrContext) {
+    const context = typeof configFileOrContext === 'string' || configFileOrContext === undefined
+        ? await (0, configurations_1.realizeGeneratorContext)(configFileOrContext)
+        : configFileOrContext;
+    return runGenerators(context);
+}
+exports.generateWithConfig = generateWithConfig;