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

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

@@ -0,0 +1,23 @@
+import Command from '../internal/base';
+export default class Validate extends Command {
+    static description: string;
+    private validationService;
+    static 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>;
+        score: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        suppressWarnings: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        suppressAllWarnings: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'log-diagnostics': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'diagnostics-format': import("@oclif/core/lib/interfaces").OptionFlag<import("@stoplight/spectral-cli/dist/services/config").OutputFormat, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'fail-severity': import("@oclif/core/lib/interfaces").OptionFlag<"error" | "warn" | "info" | "hint", import("@oclif/core/lib/interfaces").CustomOptions>;
+        'save-output': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private handleDiagnostics;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const globals_1 = require("../internal/globals");
+const validate_flags_1 = require("../internal/flags/validate.flags");
+const proxy_flags_1 = require("../internal/flags/proxy.flags");
+const validation_service_1 = require("../../../domains/services/validation.service");
+class Validate extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.validationService = new validation_service_1.ValidationService();
+    }
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { args, flags } = yield this.parse(Validate); //NOSONAR
+            let filePath = args['spec-file'];
+            const proxyHost = flags['proxyHost'];
+            const proxyPort = flags['proxyPort'];
+            if (proxyHost && proxyPort) {
+                const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+                filePath = `${filePath}+${proxyUrl}`; // Update filePath with proxyUrl
+            }
+            this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+            const watchMode = flags.watch;
+            if (watchMode) {
+                (0, globals_1.specWatcher)({
+                    spec: this.specFile,
+                    handler: this,
+                    handlerName: 'validate',
+                });
+            }
+            // Prepare validate options
+            const validateOptions = Object.assign(Object.assign({}, flags), { suppressWarnings: flags['suppressWarnings'], suppressAllWarnings: flags['suppressAllWarnings'] });
+            const result = yield this.validationService.validateDocument(this.specFile, validateOptions);
+            if (!result.success) {
+                this.error(result.error || 'Validation failed', { exit: 1 });
+            }
+            this.metricsMetadata.validation_result = result;
+            if (flags['score']) {
+                this.log(`The score of the asyncapi document is ${(_a = result.data) === null || _a === void 0 ? void 0 : _a.score}`);
+            }
+            if (flags['log-diagnostics']) {
+                yield this.handleDiagnostics(result, flags);
+            }
+            if (((_b = result.data) === null || _b === void 0 ? void 0 : _b.status) === validation_service_1.ValidationStatus.INVALID) {
+                process.exitCode = 1;
+            }
+        });
+    }
+    handleDiagnostics(result, flags) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const diagnosticsFormat = (_a = flags['diagnostics-format']) !== null && _a !== void 0 ? _a : 'stylish';
+            const writeOutput = flags['save-output'];
+            const hasIssues = (_c = (((_b = result.data) === null || _b === void 0 ? void 0 : _b.diagnostics) && result.data.diagnostics.length > 0)) !== null && _c !== void 0 ? _c : false;
+            const isFailSeverity = ((_d = result.data) === null || _d === void 0 ? void 0 : _d.status) === validation_service_1.ValidationStatus.INVALID;
+            const sourceString = ((_e = this.specFile) === null || _e === void 0 ? void 0 : _e.toSourceString()) || '';
+            const governanceMessage = this.validationService.generateGovernanceMessage(sourceString, hasIssues, isFailSeverity);
+            if (isFailSeverity) {
+                this.logToStderr(governanceMessage);
+            }
+            else {
+                this.log(governanceMessage);
+            }
+            const diagnosticsOutput = this.validationService.formatDiagnosticsOutput(((_f = result.data) === null || _f === void 0 ? void 0 : _f.diagnostics) || [], diagnosticsFormat, (_g = flags['fail-severity']) !== null && _g !== void 0 ? _g : 'error');
+            if (writeOutput) {
+                const { success, error } = yield this.validationService.saveDiagnosticsToFile(writeOutput, diagnosticsFormat, diagnosticsOutput);
+                if (!success) {
+                    this.logToStderr(error || 'Failed to save diagnostics to file', {
+                        exit: 1,
+                    });
+                }
+                else {
+                    this.log(`Diagnostics saved to ${writeOutput}`);
+                }
+            }
+            else {
+                this.log(diagnosticsOutput);
+            }
+        });
+    }
+}
+Validate.description = 'validate asyncapi file';
+Validate.flags = Object.assign(Object.assign({}, (0, validate_flags_1.validateFlags)()), (0, proxy_flags_1.proxyFlags)());
+Validate.args = {
+    'spec-file': core_1.Args.string({
+        description: 'spec path, url, or context-name',
+        required: false,
+    }),
+};
+exports.default = Validate;

package/lib/apps/cli/internal/args/generate.args.d.ts

@@ -0,0 +1,3 @@
+export declare const generateArgs: {
+    asyncapi: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+};

package/lib/apps/cli/internal/args/generate.args.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArgs = void 0;
+const core_1 = require("@oclif/core");
+exports.generateArgs = {
+    asyncapi: core_1.Args.string({
+        description: '- Local path, url or context-name pointing to AsyncAPI file',
+        required: false
+    })
+};

package/lib/apps/cli/internal/base/BaseGeneratorCommand.d.ts

@@ -0,0 +1,42 @@
+import Command from '../../internal/base';
+import { Specification } from '../../../../domains/models/SpecificationFile';
+import { Parser } from '@asyncapi/parser';
+import { ParsedFlags } from '../../../../domains/models/generate/Flags';
+import { GeneratorService } from '../../../../domains/services/generator.service';
+export interface GeneratorOptions {
+    forceWrite: boolean;
+    install: boolean;
+    debug: boolean;
+    templateParams: any;
+    noOverwriteGlobs: string[];
+    mapBaseUrlToFolder: any;
+    disabledHooks: Record<string, string>;
+    registry: {
+        url?: string;
+        auth?: string;
+        token?: string;
+    };
+}
+export declare abstract class BaseGeneratorCommand extends Command {
+    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>;
+    };
+    static args: {
+        asyncapi: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    parser: Parser;
+    protected generatorService: GeneratorService;
+    protected buildGeneratorOptions(flags: any, parsedFlags: ParsedFlags): Promise<GeneratorOptions>;
+    protected applyProxyConfiguration(asyncapi: string, proxyHost?: string, proxyPort?: string): string;
+    protected handleWatchMode(asyncapi: string, template: string, output: string, options: GeneratorOptions, genOption: any, interactive: boolean): Promise<void>;
+    protected buildGenOption(flags: any, parsedFlags: ParsedFlags): any;
+    protected generate(asyncapi: string | undefined, template: string, output: string, options: GeneratorOptions, genOption: any, interactive?: boolean): Promise<void>;
+    protected parseCommonArgs(args: Record<string, any>, output?: string): Promise<{
+        asyncapi: string;
+        output: string;
+    }>;
+    protected loadAsyncAPIInput(asyncapi: string): Promise<Specification>;
+    protected handleCancellation(value: any): void;
+    protected loadSpecificationSafely(asyncapi: string | undefined): Promise<Specification>;
+}

package/lib/apps/cli/internal/base/BaseGeneratorCommand.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGeneratorCommand = void 0;
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+// eslint-disable-next-line
+// @ts-ignore
+const generator_1 = tslib_1.__importDefault(require("@asyncapi/generator"));
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const validation_error_1 = require("../../../../errors/validation-error");
+const generator_error_1 = require("../../../../errors/generator-error");
+const parser_1 = require("@asyncapi/parser");
+const prompts_1 = require("@clack/prompts");
+const proxy_flags_1 = require("../../internal/flags/proxy.flags");
+const generate_args_1 = require("../../internal/args/generate.args");
+const watcher_1 = require("../../../../utils/generate/watcher");
+const mapBaseUrl_1 = require("../../../../utils/generate/mapBaseUrl");
+const prompts_2 = require("../../../../utils/generate/prompts");
+const generator_service_1 = require("../../../../domains/services/generator.service");
+class BaseGeneratorCommand extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.parser = new parser_1.Parser();
+        this.generatorService = new generator_service_1.GeneratorService();
+    }
+    buildGeneratorOptions(flags, parsedFlags) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return {
+                forceWrite: flags['force-write'],
+                install: flags.install,
+                debug: flags.debug,
+                templateParams: parsedFlags.params,
+                noOverwriteGlobs: flags['no-overwrite'],
+                mapBaseUrlToFolder: parsedFlags.mapBaseUrlToFolder,
+                disabledHooks: parsedFlags.disableHooks,
+                registry: {
+                    url: flags['registry-url'],
+                    auth: flags['registry-auth'],
+                    token: flags['registry-token'],
+                },
+            };
+        });
+    }
+    applyProxyConfiguration(asyncapi, proxyHost, proxyPort) {
+        if (proxyHost && proxyPort) {
+            const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+            return `${asyncapi}+${proxyUrl}`;
+        }
+        return asyncapi;
+    }
+    handleWatchMode(asyncapi, template, output, options, genOption, interactive) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const watcher = (0, watcher_1.watcherHandler)(this, asyncapi, template, output, options, genOption, interactive);
+            yield (0, watcher_1.runWatchMode)(this, asyncapi, template, output, generator_1.default, watcher);
+        });
+    }
+    buildGenOption(flags, parsedFlags) {
+        const genOption = {};
+        if (flags['map-base-url']) {
+            genOption.resolve = { resolve: (0, mapBaseUrl_1.getMapBaseUrlToFolderResolver)(parsedFlags.mapBaseUrlToFolder) };
+        }
+        return genOption;
+    }
+    generate(asyncapi_1, template_1, output_1, options_1, genOption_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (asyncapi, template, output, options, genOption, interactive = true) {
+            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));
+            }
+        });
+    }
+    parseCommonArgs(args, output) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let asyncapi = args['asyncapi'];
+            const cancellationMessage = 'Operation cancelled';
+            if (!asyncapi) {
+                asyncapi = yield (0, prompts_2.promptForAsyncAPIPath)();
+            }
+            if ((0, prompts_1.isCancel)(asyncapi)) {
+                this.error(cancellationMessage, { exit: 1 });
+            }
+            if (!output) {
+                output = yield (0, prompts_2.promptForOutputDir)();
+            }
+            if ((0, prompts_1.isCancel)(output)) {
+                this.error(cancellationMessage, { exit: 1 });
+            }
+            return { asyncapi, output };
+        });
+    }
+    loadAsyncAPIInput(asyncapi) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield (0, SpecificationFile_1.load)(asyncapi)) || (yield (0, SpecificationFile_1.load)());
+        });
+    }
+    handleCancellation(value) {
+        if ((0, prompts_1.isCancel)(value)) {
+            this.error('Operation cancelled', { exit: 1 });
+        }
+    }
+    loadSpecificationSafely(asyncapi) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (0, SpecificationFile_1.load)(asyncapi);
+            }
+            catch (err) {
+                return this.error(new validation_error_1.ValidationError({
+                    type: 'invalid-file',
+                    filepath: asyncapi,
+                }), { exit: 1 });
+            }
+        });
+    }
+}
+exports.BaseGeneratorCommand = BaseGeneratorCommand;
+BaseGeneratorCommand.flags = Object.assign({}, (0, proxy_flags_1.proxyFlags)());
+BaseGeneratorCommand.args = Object.assign({}, generate_args_1.generateArgs);

package/lib/apps/cli/internal/base.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+import { MetricMetadata, Recorder } from '@smoya/asyncapi-adoption-metrics';
+import { Parser } from '@asyncapi/parser';
+import { Specification } from '../../../domains/models/SpecificationFile';
+export default abstract class extends Command {
+    recorder: Promise<Recorder>;
+    parser: Parser;
+    metricsMetadata: MetricMetadata;
+    specFile: Specification | undefined;
+    init(): Promise<void>;
+    catch(err: Error & {
+        exitCode?: number;
+    }): Promise<any>;
+    recordActionFinished(action: string, metadata?: MetricMetadata, rawDocument?: string): Promise<void>;
+    recordActionInvoked(action: string, metadata?: MetricMetadata): Promise<void>;
+    recordActionMetric(recordFunc: (recorder: Recorder) => Promise<void>): Promise<void>;
+    setSource(): Promise<void>;
+    finally(error: Error | undefined): Promise<any>;
+    recorderFromEnv(prefix: string): Promise<Recorder>;
+}

package/lib/apps/cli/internal/base.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const asyncapi_adoption_metrics_1 = require("@smoya/asyncapi-adoption-metrics");
+const parser_1 = require("@asyncapi/parser");
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const fs_1 = require("fs");
+const uuid_1 = require("uuid");
+const os_1 = require("os");
+const { readFile, writeFile, stat } = fs_1.promises;
+class DiscardSink {
+    send() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // noop
+        });
+    }
+}
+class default_1 extends core_1.Command {
+    constructor() {
+        super(...arguments);
+        this.recorder = this.recorderFromEnv('asyncapi_adoption');
+        this.parser = new parser_1.Parser();
+        this.metricsMetadata = {};
+    }
+    init() {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield _super.init.call(this);
+            const commandName = this.id || '';
+            yield this.recordActionInvoked(commandName, this.metricsMetadata);
+        });
+    }
+    catch(err) {
+        const _super = Object.create(null, {
+            catch: { get: () => super.catch }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield _super.catch.call(this, err);
+            }
+            catch (e) {
+                if (e.message.includes('EEXIT: 0')) {
+                    process.exitCode = 0;
+                    return;
+                }
+                if (e instanceof Error) {
+                    this.logToStderr(`${e.name}: ${e.message}`);
+                    process.exitCode = 1;
+                }
+            }
+        });
+    }
+    recordActionFinished(action_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (action, metadata = {}, rawDocument) {
+            if (rawDocument !== undefined) {
+                try {
+                    const { document } = yield this.parser.parse(rawDocument);
+                    if (document !== undefined) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        metadata = (0, asyncapi_adoption_metrics_1.MetadataFromDocument)(document, metadata);
+                    }
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        this.log(`Skipping submitting anonymous metrics due to the following error: ${e.name}: ${e.message}`);
+                    }
+                }
+            }
+            const callable = function (recorder) {
+                return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield recorder.recordActionFinished(action, metadata);
+                });
+            };
+            yield this.recordActionMetric(callable);
+        });
+    }
+    recordActionInvoked(action, metadata) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const callable = function (recorder) {
+                return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield recorder.recordActionInvoked(action, metadata);
+                });
+            };
+            yield this.recordActionMetric(callable);
+        });
+    }
+    recordActionMetric(recordFunc) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.setSource();
+                yield recordFunc(yield this.recorder);
+                yield (yield this.recorder).flush();
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    this.log(`Skipping submitting anonymous metrics due to the following error: ${e.name}: ${e.message}`);
+                }
+            }
+        });
+    }
+    setSource() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const specFilePath = (_a = this.specFile) === null || _a === void 0 ? void 0 : _a.getFilePath();
+            if (!specFilePath) {
+                return;
+            }
+            try {
+                const stats = yield stat(specFilePath);
+                this.metricsMetadata['file_creation_timestamp'] = stats.birthtimeMs;
+            }
+            catch (e) {
+                // If there's an error with the file, we don't handle it here because it's expected to be handled and reported in the 'finally' method of the command.
+            }
+        });
+    }
+    finally(error) {
+        const _super = Object.create(null, {
+            finally: { get: () => super.finally }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield _super.finally.call(this, error);
+            this.metricsMetadata['success'] = error === undefined;
+            yield this.recordActionFinished(this.id, this.metricsMetadata, (_a = this.specFile) === null || _a === void 0 ? void 0 : _a.text());
+        });
+    }
+    recorderFromEnv(prefix) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let sink = new DiscardSink();
+            const analyticsConfigFile = process.env.ASYNCAPI_METRICS_CONFIG_PATH ||
+                (0, path_1.join)((0, os_1.homedir)(), '.asyncapi-analytics');
+            if (!(0, fs_extra_1.existsSync)(analyticsConfigFile)) {
+                yield writeFile(analyticsConfigFile, JSON.stringify({
+                    analyticsEnabled: 'true',
+                    infoMessageShown: 'false',
+                    userID: (0, uuid_1.v4)(),
+                }), { encoding: 'utf8' });
+            }
+            const analyticsConfigFileContent = JSON.parse(yield readFile((0, path_1.resolve)(analyticsConfigFile), { encoding: 'utf8' }));
+            this.metricsMetadata['user'] = analyticsConfigFileContent.userID;
+            if (analyticsConfigFileContent.analyticsEnabled !== 'false' &&
+                process.env.CI !== 'true') {
+                switch (process.env.NODE_ENV) {
+                    case 'development':
+                        // NODE_ENV set to `development` in bin/run
+                        if (!process.env.TEST) {
+                            // Do not pollute stdout when running tests
+                            sink = new asyncapi_adoption_metrics_1.StdOutSink();
+                        }
+                        break;
+                    case 'production':
+                        // NODE_ENV set to `production` in bin/run_bin, which is specified in 'bin' package.json section
+                        sink = new asyncapi_adoption_metrics_1.NewRelicSink(process.env.ASYNCAPI_METRICS_NEWRELIC_KEY ||
+                            'eu01xx73a8521047150dd9414f6aedd2FFFFNRAL');
+                        if (analyticsConfigFileContent.infoMessageShown === 'false') {
+                            this.log('\nAsyncAPI anonymously tracks command executions to improve the specification and tools, ensuring no sensitive data reaches our servers. It aids in comprehending how AsyncAPI tools are used and adopted, facilitating ongoing improvements to our specifications and tools.\n\nTo disable tracking, please run the following command:\n  asyncapi config analytics --disable\n\nOnce disabled, if you want to enable tracking back again then run:\n  asyncapi config analytics --enable\n');
+                            analyticsConfigFileContent.infoMessageShown = 'true';
+                            yield writeFile(analyticsConfigFile, JSON.stringify(analyticsConfigFileContent), { encoding: 'utf8' });
+                        }
+                        break;
+                }
+            }
+            return new asyncapi_adoption_metrics_1.Recorder(prefix, sink);
+        });
+    }
+}
+exports.default = default_1;

package/lib/apps/cli/internal/flags/bundle.flags.d.ts

@@ -0,0 +1,7 @@
+export declare const bundleFlags: () => {
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    base: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    baseDir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    xOrigin: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};

package/lib/apps/cli/internal/flags/bundle.flags.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleFlags = void 0;
+const core_1 = require("@oclif/core");
+const bundleFlags = () => {
+    return {
+        help: core_1.Flags.help({ char: 'h' }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'The output file name. Omitting this flag the result will be printed in the console.',
+        }),
+        base: core_1.Flags.string({
+            char: 'b',
+            description: 'Path to the file which will act as a base. This is required when some properties need to be overwritten.',
+        }),
+        baseDir: core_1.Flags.string({
+            char: 'd',
+            description: 'One relative/absolute path to directory relative to which paths to AsyncAPI Documents that should be bundled will be resolved.',
+        }),
+        xOrigin: core_1.Flags.boolean({
+            char: 'x',
+            description: 'Pass this switch to generate properties "x-origin" that will contain historical values of dereferenced "$ref"s.',
+        }),
+    };
+};
+exports.bundleFlags = bundleFlags;

package/lib/apps/cli/internal/flags/config/analytics.flags.d.ts

@@ -0,0 +1,6 @@
+export declare const analyticsFlags: () => {
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    disable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    enable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    status: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};

package/lib/apps/cli/internal/flags/config/analytics.flags.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsFlags = void 0;
+const core_1 = require("@oclif/core");
+const analyticsFlags = () => {
+    return {
+        help: core_1.Flags.help({ char: 'h' }),
+        disable: core_1.Flags.boolean({
+            char: 'd',
+            description: 'disable analytics',
+            default: false,
+        }),
+        enable: core_1.Flags.boolean({
+            char: 'e',
+            description: 'enable analytics',
+            default: false,
+        }),
+        status: core_1.Flags.boolean({
+            char: 's',
+            description: 'show current status of analytics',
+        }),
+    };
+};
+exports.analyticsFlags = analyticsFlags;

package/lib/apps/cli/internal/flags/config/context.flags.d.ts

@@ -0,0 +1,4 @@
+export declare const addFlags: () => {
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    'set-current': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};

package/lib/apps/cli/internal/flags/config/context.flags.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFlags = void 0;
+const core_1 = require("@oclif/core");
+const addFlags = () => {
+    return {
+        help: core_1.Flags.help({ char: 'h' }),
+        'set-current': core_1.Flags.boolean({
+            char: 's',
+            description: 'Set context being added as the current context',
+            default: false,
+            required: false,
+        }),
+    };
+};
+exports.addFlags = addFlags;

package/lib/apps/cli/internal/flags/convert.flags.d.ts

@@ -0,0 +1,7 @@
+export declare const convertFlags: (latestVersion: string) => {
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'target-version': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    perspective: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+};

package/lib/apps/cli/internal/flags/convert.flags.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFlags = void 0;
+const core_1 = require("@oclif/core");
+const convertFlags = (latestVersion) => {
+    return {
+        help: core_1.Flags.help({ char: 'h' }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'path to the file where the result is saved',
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Specify the format to convert from (openapi or asyncapi)',
+            options: ['openapi', 'asyncapi', 'postman-collection'],
+            required: true,
+            default: 'asyncapi',
+        }),
+        'target-version': core_1.Flags.string({
+            char: 't',
+            description: 'asyncapi version to convert to',
+            default: latestVersion,
+        }),
+        perspective: core_1.Flags.string({
+            char: 'p',
+            description: 'Perspective to use when converting OpenAPI to AsyncAPI (client or server). Note: This option is only applicable for OpenAPI to AsyncAPI conversions.',
+            options: ['client', 'server'],
+            default: 'server',
+        }),
+    };
+};
+exports.convertFlags = convertFlags;

package/lib/apps/cli/internal/flags/diff.flags.d.ts

@@ -0,0 +1,13 @@
+export declare const diffFlags: () => {
+    'log-diagnostics': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    'diagnostics-format': import("@oclif/core/lib/interfaces").OptionFlag<import("@stoplight/spectral-cli/dist/services/config").OutputFormat, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'fail-severity': import("@oclif/core/lib/interfaces").OptionFlag<"error" | "warn" | "info" | "hint", import("@oclif/core/lib/interfaces").CustomOptions>;
+    'save-output': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    type: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    markdownSubtype: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    overrides: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'no-error': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};