@asyncapi-actions-test/trusted-publishing-test_asyncapi-cli 4.1.3

package/lib/apps/cli/commands/diff.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable sonarjs/no-duplicate-string */
+const core_1 = require("@oclif/core");
+const diff = tslib_1.__importStar(require("@asyncapi/diff"));
+const fs_1 = require("fs");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const validation_error_1 = require("../../../errors/validation-error");
+const specification_file_1 = require("../../../errors/specification-file");
+const diff_error_1 = require("../../../errors/diff-error");
+const globals_1 = require("../internal/globals");
+const diff_flags_1 = require("../internal/flags/diff.flags");
+const validation_service_1 = require("../../../domains/services/validation.service");
+const { readFile } = fs_1.promises;
+class Diff extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.validationService = new validation_service_1.ValidationService();
+    }
+    /* eslint-disable sonarjs/cognitive-complexity */
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(Diff); // NOSONAR
+            const firstDocumentPath = args['old'];
+            const secondDocumentPath = args['new'];
+            const outputFormat = flags['format'];
+            const outputType = flags['type'];
+            const overrideFilePath = flags['overrides'];
+            let markdownSubtype = flags['markdownSubtype'];
+            const watchMode = flags['watch'];
+            const noError = flags['no-error'];
+            const writeOutput = flags['save-output'];
+            let firstDocument, secondDocument;
+            checkAndWarnFalseFlag(outputFormat, markdownSubtype);
+            markdownSubtype = setDefaultMarkdownSubtype(outputFormat, markdownSubtype);
+            this.metricsMetadata.output_format = outputFormat;
+            this.metricsMetadata.output_type = outputType;
+            if (outputFormat === 'md') {
+                this.metricsMetadata.output_markdown_subtype = flags['markdownSubtype'];
+            }
+            try {
+                firstDocument = yield (0, SpecificationFile_1.load)(firstDocumentPath);
+                enableWatch(watchMode, {
+                    spec: firstDocument,
+                    handler: this,
+                    handlerName: 'diff',
+                    docVersion: 'old',
+                    label: 'DIFF_OLD',
+                });
+            }
+            catch (err) {
+                if (err instanceof specification_file_1.SpecificationFileNotFound) {
+                    this.error(new validation_error_1.ValidationError({
+                        type: 'invalid-file',
+                        filepath: firstDocumentPath,
+                    }));
+                }
+                this.error(err);
+            }
+            try {
+                secondDocument = yield (0, SpecificationFile_1.load)(secondDocumentPath);
+                enableWatch(watchMode, {
+                    spec: secondDocument,
+                    handler: this,
+                    handlerName: 'diff',
+                    docVersion: 'new',
+                    label: 'DIFF_NEW',
+                });
+            }
+            catch (err) {
+                if (err instanceof specification_file_1.SpecificationFileNotFound) {
+                    this.error(new validation_error_1.ValidationError({
+                        type: 'invalid-file',
+                        filepath: secondDocumentPath,
+                    }));
+                }
+                this.error(err);
+            }
+            let overrides = {};
+            if (overrideFilePath) {
+                try {
+                    overrides = yield readOverrideFile(overrideFilePath);
+                }
+                catch (err) {
+                    this.error(err);
+                }
+            }
+            try {
+                const parsed = yield this.parseDocuments(this, firstDocument, secondDocument, flags);
+                if (!parsed) {
+                    return;
+                }
+                const diffOutput = diff.diff(parsed.firstDocumentParsed.json(), parsed.secondDocumentParsed.json(), {
+                    override: overrides,
+                    outputType: outputFormat, // NOSONAR
+                    markdownSubtype: markdownSubtype,
+                });
+                if (writeOutput) {
+                    yield this.writeOutputToFile(diffOutput, outputType, writeOutput, outputFormat);
+                }
+                else {
+                    if (outputFormat === 'json') {
+                        this.outputJSON(diffOutput, outputType);
+                    }
+                    else if (outputFormat === 'yaml' || outputFormat === 'yml') {
+                        this.outputYAML(diffOutput, outputType);
+                    }
+                    else if (outputFormat === 'md') {
+                        this.outputMarkdown(diffOutput, outputType);
+                    }
+                    else {
+                        this.log(`The output format ${outputFormat} is not supported at the moment.`);
+                    }
+                    if (!noError) {
+                        throwOnBreakingChange(diffOutput, outputFormat);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof diff_error_1.DiffBreakingChangeError ||
+                    error instanceof TypeError) {
+                    this.error(error);
+                }
+                throw new validation_error_1.ValidationError({
+                    type: 'parser-error',
+                    err: error,
+                });
+            }
+        });
+    }
+    outputJSON(diffOutput, outputType) {
+        if (outputType === 'breaking') {
+            this.log(JSON.stringify(diffOutput.breaking(), null, 2));
+        }
+        else if (outputType === 'non-breaking') {
+            this.log(JSON.stringify(diffOutput.nonBreaking(), null, 2));
+        }
+        else if (outputType === 'unclassified') {
+            this.log(JSON.stringify(diffOutput.unclassified(), null, 2));
+        }
+        else if (outputType === 'all') {
+            this.log(JSON.stringify(diffOutput.getOutput(), null, 2));
+        }
+        else {
+            this.log(`The output type ${outputType} is not supported at the moment.`);
+        }
+    }
+    writeOutputToFile(diffOutput, outputType, filePath, outputFormat) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let content;
+            if (outputFormat === 'json') {
+                if (outputType === 'breaking') {
+                    content = JSON.stringify(diffOutput.breaking(), null, 2);
+                }
+                else if (outputType === 'non-breaking') {
+                    content = JSON.stringify(diffOutput.nonBreaking(), null, 2);
+                }
+                else if (outputType === 'unclassified') {
+                    content = JSON.stringify(diffOutput.unclassified(), null, 2);
+                }
+                else if (outputType === 'all') {
+                    content = JSON.stringify(diffOutput.getOutput(), null, 2);
+                }
+                else {
+                    content = `The output type ${outputType} is not supported at the moment.`;
+                }
+            }
+            else if (outputFormat === 'yaml' || outputFormat === 'yml') {
+                content = genericOutput(diffOutput, outputType);
+            }
+            else if (outputFormat === 'md') {
+                content = genericOutput(diffOutput, outputType);
+            }
+            else {
+                content = `The output format ${outputFormat} is not supported at the moment.`;
+            }
+            try {
+                yield fs_1.promises.writeFile(filePath, content);
+                this.log(`Output successfully written to: ${filePath}`);
+            }
+            catch (error) {
+                this.error(`Failed to write output to file: ${error.message}`);
+            }
+        });
+    }
+    outputYAML(diffOutput, outputType) {
+        this.log(genericOutput(diffOutput, outputType));
+    }
+    outputMarkdown(diffOutput, outputType) {
+        this.log(genericOutput(diffOutput, outputType));
+    }
+    parseDocuments(command, firstDocument, secondDocument, flags) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const firstResult = yield this.validationService.parseDocument(firstDocument, {}, flags);
+            const secondResult = yield this.validationService.parseDocument(secondDocument, {}, flags);
+            if (!firstResult.success || !secondResult.success) {
+                this.error(new validation_error_1.ValidationError({
+                    type: 'invalid-file',
+                    filepath: firstDocument.getFilePath() || secondDocument.getFilePath(),
+                    err: firstResult.error || secondResult.error,
+                }));
+            }
+            if (!firstResult.data || !secondResult.data) {
+                return;
+            }
+            const { document: firstDocumentParsed, status: firstDocumentStatus, diagnostics: firstDiagnostics, } = firstResult.data;
+            const { document: secondDocumentParsed, status: secondDocumentStatus, diagnostics: secondDiagnostics, } = secondResult.data;
+            if (flags['log-diagnostics']) {
+                this.log(`Diagnostics for ${firstDocument.getFilePath() || firstDocument.getFileURL()}:`);
+                this.handleGovernanceMessage(firstDocument, firstDiagnostics, firstDocumentStatus);
+                this.log(this.validationService.formatDiagnosticsOutput(firstDiagnostics, flags['diagnostics-format'], flags['fail-severity']));
+                this.log(`Diagnostics for ${secondDocument.getFilePath() || secondDocument.getFileURL()}:`);
+                this.handleGovernanceMessage(secondDocument, secondDiagnostics, secondDocumentStatus);
+                this.log(this.validationService.formatDiagnosticsOutput(secondDiagnostics, flags['diagnostics-format'], flags['fail-severity']));
+            }
+            if (!firstDocumentParsed ||
+                !secondDocumentParsed ||
+                firstDocumentStatus === 'invalid' ||
+                secondDocumentStatus === 'invalid') {
+                return;
+            }
+            return { firstDocumentParsed, secondDocumentParsed };
+        });
+    }
+    handleGovernanceMessage(document, diagnostics, status) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const sourceString = document.toSourceString();
+            const hasIssues = diagnostics && diagnostics.length > 0;
+            const isFailSeverity = status === validation_service_1.ValidationStatus.INVALID;
+            const governanceMessage = this.validationService.generateGovernanceMessage(sourceString, hasIssues, isFailSeverity);
+            if (isFailSeverity) {
+                this.logToStderr(governanceMessage);
+            }
+            else {
+                this.log(governanceMessage);
+            }
+        });
+    }
+}
+Diff.description = 'Find diff between two asyncapi files';
+Diff.flags = (0, diff_flags_1.diffFlags)();
+Diff.args = {
+    old: core_1.Args.string({
+        description: 'old spec path, URL or context-name',
+        required: true,
+    }),
+    new: core_1.Args.string({
+        description: 'new spec path, URL or context-name',
+        required: true,
+    }),
+};
+exports.default = Diff;
+/**
+ * A generic output function for diff output
+ * @param diffOutput The diff output data
+ * @param outputType The output format requested by the user
+ * @returns The output(if the format exists) or a message indicating the format doesn't exist
+ */
+function genericOutput(diffOutput, outputType) {
+    switch (outputType) {
+        case 'breaking':
+            return diffOutput.breaking();
+        case 'non-breaking':
+            return diffOutput.nonBreaking();
+        case 'unclassified':
+            return diffOutput.unclassified();
+        case 'all':
+            return diffOutput.getOutput();
+        default:
+            return `The output type ${outputType} is not supported at the moment.`;
+    }
+}
+/**
+ * Reads the file from give path and parses it as JSON
+ * @param path The path to override file
+ * @returns The override object
+ */
+function readOverrideFile(path) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let overrideStringData;
+        try {
+            overrideStringData = yield readFile(path, { encoding: 'utf8' });
+        }
+        catch (err) {
+            throw new diff_error_1.DiffOverrideFileError();
+        }
+        try {
+            return JSON.parse(overrideStringData);
+        }
+        catch (err) {
+            throw new diff_error_1.DiffOverrideJSONError();
+        }
+    });
+}
+/**
+ * function to enable watchmode.
+ * The function is abstracted here, to avoid eslint cognitive complexity error.
+ */
+const enableWatch = (status, watcher) => {
+    if (status) {
+        (0, globals_1.specWatcher)(watcher);
+    }
+};
+/**
+ * Throws `DiffBreakingChangeError` when breaking changes are detected
+ */
+function throwOnBreakingChange(diffOutput, outputFormat) {
+    const breakingChanges = diffOutput.breaking();
+    if ((outputFormat === 'json' && breakingChanges.length !== 0) ||
+        ((outputFormat === 'yaml' || outputFormat === 'yml') &&
+            breakingChanges !== '[]\n')) {
+        throw new diff_error_1.DiffBreakingChangeError();
+    }
+}
+/**
+ * Checks and warns user about providing unnecessary markdownSubtype option.
+ */
+function checkAndWarnFalseFlag(format, markdownSubtype) {
+    if (format !== 'md' && typeof markdownSubtype !== 'undefined') {
+        const warningMessage = chalk_1.default.yellowBright(`Warning: The given markdownSubtype flag will not work with the given format.\nProvided flag markdownSubtype: ${markdownSubtype}`);
+        console.log(warningMessage);
+    }
+}
+/**
+ * Sets the default markdownSubtype option in case user doesn't provide one.
+ */
+function setDefaultMarkdownSubtype(format, markdownSubtype) {
+    if (format === 'md' && typeof markdownSubtype === 'undefined') {
+        return 'yaml';
+    }
+    return markdownSubtype;
+}

package/lib/apps/cli/commands/format.d.ts

@@ -0,0 +1,18 @@
+import Command from '../internal/base';
+export default class Convert extends Command {
+    static specFile: any;
+    static metricsMetadata: any;
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private handleConversion;
+    private handleOutput;
+    private removeExtensionFromOutputPath;
+}

package/lib/apps/cli/commands/format.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const fs_1 = require("fs");
+const core_1 = require("@oclif/core");
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const specification_file_1 = require("../../../errors/specification-file");
+const picocolors_1 = require("picocolors");
+const format_flags_1 = require("../internal/flags/format.flags");
+class Convert extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(Convert);
+            const filePath = args['spec-file'];
+            const outputFileFormat = flags['format'];
+            let convertedFile;
+            try {
+                this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+                // eslint-disable-next-line sonarjs/no-duplicate-string
+                this.metricsMetadata.to_version = flags['target-version'];
+                const ff = (0, SpecificationFile_1.retrieveFileFormat)(this.specFile.text());
+                const isSpecFileJson = ff === 'json';
+                const isSpecFileYaml = ff === 'yaml';
+                if (!isSpecFileJson && !isSpecFileYaml) {
+                    throw new specification_file_1.SpecificationWrongFileFormat(filePath);
+                }
+                convertedFile = this.handleConversion(isSpecFileJson, isSpecFileYaml, outputFileFormat);
+                if (!convertedFile) {
+                    return;
+                }
+                yield this.handleOutput(flags.output, convertedFile, outputFileFormat);
+            }
+            catch (err) {
+                this.error(err);
+            }
+        });
+    }
+    handleConversion(isSpecFileJson, isSpecFileYaml, outputFileFormat) {
+        var _a;
+        const text = (_a = this.specFile) === null || _a === void 0 ? void 0 : _a.text();
+        if (isSpecFileJson && text) {
+            if (outputFileFormat === 'json') {
+                throw new Error(`Your document is already a ${(0, picocolors_1.cyan)('JSON')}`);
+            }
+            return (0, SpecificationFile_1.convertToYaml)(text);
+        }
+        if (isSpecFileYaml && text) {
+            if (outputFileFormat === 'yaml' || outputFileFormat === 'yml') {
+                throw new Error(`Your document is already a ${(0, picocolors_1.cyan)('YAML')}`);
+            }
+            return (0, SpecificationFile_1.convertToJSON)(text);
+        }
+    }
+    handleOutput(outputPath, formattedFile, outputFileFormat) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (outputPath) {
+                outputPath = this.removeExtensionFromOutputPath(outputPath);
+                const finalFileName = `${outputPath}.${outputFileFormat}`;
+                yield fs_1.promises.writeFile(finalFileName, formattedFile, {
+                    encoding: 'utf8',
+                });
+                this.log(`succesfully formatted to ${outputFileFormat} at ${(0, picocolors_1.green)(finalFileName)} ✅`);
+            }
+            else {
+                this.log(formattedFile);
+                this.log(`succesfully logged after formatting to ${outputFileFormat} ✅`);
+            }
+        });
+    }
+    removeExtensionFromOutputPath(filename) {
+        var _a;
+        // Removes the extension from a filename if it is .json, .yaml, or .yml
+        // this is so that we can remove the provided extension name in the -o flag and
+        // apply our own extension name according to the content of the file
+        const validExtensions = ['json', 'yaml', 'yml'];
+        const parts = filename.split('.');
+        if (parts.length > 1) {
+            const extension = (_a = parts.pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (extension && validExtensions.includes(extension)) {
+                return parts.join('.');
+            }
+        }
+        return filename;
+    }
+}
+Convert.metricsMetadata = {};
+Convert.description = 'Convert asyncapi documents from any format to yaml, yml or JSON';
+Convert.flags = (0, format_flags_1.convertFormatFlags)();
+Convert.args = {
+    'spec-file': core_1.Args.string({
+        description: 'spec path, url, or context-name',
+        required: false,
+    }),
+};
+exports.default = Convert;

package/lib/apps/cli/commands/generate/client.d.ts

@@ -0,0 +1,30 @@
+import { BaseGeneratorCommand } from '../../internal/base/BaseGeneratorCommand';
+export default class Client extends BaseGeneratorCommand {
+    static description: string;
+    static examples: string[];
+    static readonly flags: {
+        proxyHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        proxyPort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'disable-hook': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        install: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-overwrite': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'force-write': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        param: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'map-base-url': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-url': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-auth': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-token': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        asyncapi: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        language: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private parseArgs;
+    private getTemplateName;
+}

package/lib/apps/cli/commands/generate/client.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const BaseGeneratorCommand_1 = require("../../internal/base/BaseGeneratorCommand");
+// eslint-disable-next-line
+// @ts-ignore
+const generator_1 = require("@asyncapi/generator");
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = require("picocolors");
+const clients_flags_1 = require("../../internal/flags/generate/clients.flags");
+const flags_1 = require("../../../../utils/generate/flags");
+const prompts_2 = require("../../../../utils/generate/prompts");
+const ClientLanguages_1 = require("../../../../domains/models/generate/ClientLanguages");
+const generator_error_1 = require("../../../../errors/generator-error");
+class Client extends BaseGeneratorCommand_1.BaseGeneratorCommand {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const { args, flags } = yield this.parse(Client); // NOSONAR
+            const interactive = !flags['no-interactive'];
+            let asyncapi = (_a = args['asyncapi']) !== null && _a !== void 0 ? _a : '';
+            let language = args['language'];
+            let output = flags.output;
+            const { proxyPort, proxyHost } = flags;
+            if (interactive) {
+                (0, prompts_1.intro)((0, picocolors_1.inverse)('Client generation with AsyncAPI Generator'));
+                (0, prompts_1.note)((0, picocolors_1.yellow)('This feature is in the experimental phase. Please provide feedback at: https://github.com/asyncapi/generator/issues'));
+                const parsedArgs = yield this.parseArgs(args, output);
+                asyncapi = parsedArgs.asyncapi;
+                language = parsedArgs.language;
+                output = parsedArgs.output;
+            }
+            const template = this.getTemplateName(language);
+            const parsedFlags = (0, flags_1.parseGeneratorFlags)(flags['disable-hook'], flags['param'], flags['map-base-url'], flags['registry-url'], flags['registry-auth'], flags['registry-token']);
+            const options = yield this.buildGeneratorOptions(flags, parsedFlags);
+            // Apply proxy configuration using base class method
+            asyncapi = this.applyProxyConfiguration(asyncapi, proxyHost, proxyPort);
+            const asyncapiInput = yield this.loadAsyncAPIInput(asyncapi);
+            this.specFile = asyncapiInput;
+            this.metricsMetadata.language = language;
+            const watchTemplate = flags['watch'];
+            const genOption = this.buildGenOption(flags, parsedFlags);
+            // Use GeneratorService for client generation
+            const specification = yield this.loadSpecificationSafely(asyncapi);
+            const result = yield this.generatorService.generate(specification, template, output, options, // GeneratorService expects different options interface
+            genOption, interactive);
+            if (!result.success) {
+                throw new generator_error_1.GeneratorError(new Error(result.error));
+            }
+            this.log((_c = (_b = result.data) === null || _b === void 0 ? void 0 : _b.logs) === null || _c === void 0 ? void 0 : _c.join('\n'));
+            if (watchTemplate) {
+                yield this.handleWatchMode(asyncapi, template, output, options, genOption, interactive);
+            }
+        });
+    }
+    parseArgs(args, output) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Use base class method for common args
+            const commonArgs = yield this.parseCommonArgs(args, output);
+            let language = args['language'];
+            if (!language) {
+                const defaultLanguage = (0, ClientLanguages_1.getDefaultLanguage)();
+                language = (yield (0, prompts_2.promptForLanguage)(defaultLanguage));
+            }
+            this.handleCancellation(language);
+            return {
+                asyncapi: commonArgs.asyncapi,
+                language,
+                output: commonArgs.output
+            };
+        });
+    }
+    getTemplateName(language) {
+        var _a;
+        const template = (_a = (0, generator_1.listBakedInTemplates)({ type: 'client' }).find((template) => {
+            return template.target === language;
+        })) === null || _a === void 0 ? void 0 : _a.name;
+        if (!template) {
+            this.log(`❌ Client generation for "${language}" is not yet available.`);
+            this.log(`✅ Available languages: ${ClientLanguages_1.availableLanguages.join(', ')}`);
+            this.log('🙏 Help us create the missing one. Start discussion at: https://github.com/asyncapi/generator/issues.');
+            this.exit(1);
+        }
+        return template;
+    }
+}
+Client.description = `Generates clients baked-in AsyncAPI Generator. Available for: ${ClientLanguages_1.availableLanguages.join(', ')}. If some language is not supported or you want to improve existing client, join us at https://github.com/asyncapi/generator`;
+Client.examples = [
+    'asyncapi generate client javascript asyncapi.yaml --param version=1.0.0 singleFile=true --output ./docs --force-write'
+];
+Client.flags = Object.assign(Object.assign({}, (0, clients_flags_1.clientsFlags)()), BaseGeneratorCommand_1.BaseGeneratorCommand.flags);
+Client.args = Object.assign({ language: core_1.Args.string({ description: `The language you want the client generated for. Available target languages: ${ClientLanguages_1.availableLanguages.join(', ')}`, required: true }) }, BaseGeneratorCommand_1.BaseGeneratorCommand.args);
+exports.default = Client;

package/lib/apps/cli/commands/generate/fromTemplate.d.ts

@@ -0,0 +1,29 @@
+import { BaseGeneratorCommand } from '../../internal/base/BaseGeneratorCommand';
+export default class Template extends BaseGeneratorCommand {
+    static description: string;
+    static examples: string[];
+    static readonly flags: {
+        proxyHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        proxyPort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'disable-hook': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        install: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-overwrite': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'force-write': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        param: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'map-base-url': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-url': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-auth': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'registry-token': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static args: {
+        template: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        asyncapi: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<undefined>;
+    private parseArgs;
+}