@asyncapi/cli 3.2.0 → 3.3.0

package/lib/{core → domains}/models/Preview.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_PORT = void 0;
 exports.startPreview = startPreview;
 const tslib_1 = require("tslib");
-const specification_file_1 = require("../errors/specification-file");
+const specification_file_1 = require("../../errors/specification-file");
 const fs_1 = require("fs");
 const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
 const http_1 = require("http");
@@ -30,11 +30,13 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
         throw new specification_file_1.SpecificationFileNotFound(filePath);
     }
     const baseDir = path_1.default.dirname(path_1.default.resolve(filePath));
-    (0, bundler_1.default)(filePath).then((doc) => {
+    (0, bundler_1.default)(filePath)
+        .then((doc) => {
         if (doc) {
             bundleError = false;
         }
-    }).catch((err) => {
+    })
+        .catch((err) => {
         if (suppressLogs) {
             console.log(defaultErrorMessage);
         }
@@ -57,13 +59,13 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
         sendQueuedMessages();
     });
     wsServer.on('close', (socket) => {
-        sockets.splice(sockets.findIndex(s => s === socket));
+        sockets.splice(sockets.findIndex((s) => s === socket));
     });
     app.prepare().then(() => {
         if (filePath && !bundleError) {
             messageQueue.push(JSON.stringify({
                 type: 'preview:connected',
-                code: 'Preview server connected'
+                code: 'Preview server connected',
             }));
             sendQueuedMessages();
             findPathsToWatchFromSchemaRef(filePath, baseDir);
@@ -75,14 +77,18 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
                             base,
                             baseDir: baseDirectory,
                             xOrigin,
-                        }).then((intitalDocument) => {
+                        })
+                            .then((intitalDocument) => {
                             messageQueue.push(JSON.stringify({
                                 type: 'preview:file:added',
-                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
-                                    intitalDocument.yml() : intitalDocument.string()
+                                code: path_1.default.extname(filePath) === '.yaml' ||
+                                    path_1.default.extname(filePath) === '.yml'
+                                    ? intitalDocument.yml()
+                                    : intitalDocument.string(),
                             }));
                             sendQueuedMessages();
-                        }).catch((e) => {
+                        })
+                            .catch((e) => {
                             if (suppressLogs) {
                                 console.log(defaultErrorMessage);
                             }
@@ -96,14 +102,18 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
                             base,
                             baseDir: baseDirectory,
                             xOrigin,
-                        }).then((modifiedDocument) => {
+                        })
+                            .then((modifiedDocument) => {
                             messageQueue.push(JSON.stringify({
                                 type: 'preview:file:changed',
-                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
-                                    modifiedDocument.yml() : modifiedDocument.string()
+                                code: path_1.default.extname(filePath) === '.yaml' ||
+                                    path_1.default.extname(filePath) === '.yml'
+                                    ? modifiedDocument.yml()
+                                    : modifiedDocument.string(),
                             }));
                             sendQueuedMessages();
-                        }).catch((error) => {
+                        })
+                            .catch((error) => {
                             if (suppressLogs) {
                                 console.log(defaultErrorMessage);
                             }
@@ -124,7 +134,8 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
         }
         const server = (0, http_1.createServer)((req, res) => handle(req, res));
         server.on('upgrade', (request, socket, head) => {
-            if (request.url === '/preview-server' && request.headers['origin'] === `http://localhost:${port}`) {
+            if (request.url === '/preview-server' &&
+                request.headers['origin'] === `http://localhost:${port}`) {
                 console.log('🔗 WebSocket connection established for the preview.');
                 wsServer.handleUpgrade(request, socket, head, (sock) => {
                     wsServer.emit('connection', sock, request);
@@ -136,7 +147,8 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
             }
         });
         if (!bundleError) {
-            server.listen(port, () => {
+            server
+                .listen(port, () => {
                 const url = `http://localhost:${port}?previewServer=${port}&studio-version=${package_json_1.version}`;
                 console.log(`🎉 Connected to Preview Server running at ${(0, picocolors_1.blueBright)(url)}.`);
                 console.log(`🌐 Open this URL in your web browser: ${(0, picocolors_1.blueBright)(url)}`);
@@ -152,7 +164,8 @@ function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port
                 if (!bundleError) {
                     (0, open_1.default)(url);
                 }
-            }).on('error', (error) => {
+            })
+                .on('error', (error) => {
                 console.error(`Failed to start server on port ${port}:`, error.message);
             });
         }
@@ -167,9 +180,12 @@ function sendQueuedMessages() {
     }
 }
 function isLocalRefAPath(key, value) {
-    return (typeof value === 'string' && key === '$ref' &&
-        (value.startsWith('.') || value.startsWith('./') ||
-            value.startsWith('../') || !value.startsWith('#')));
+    return (typeof value === 'string' &&
+        key === '$ref' &&
+        (value.startsWith('.') ||
+            value.startsWith('./') ||
+            value.startsWith('../') ||
+            !value.startsWith('#')));
 }
 function findPathsToWatchFromSchemaRef(filePath, baseDir) {
     if (filePath && !isValidFilePath(filePath)) {

package/lib/{core → domains}/models/SpecificationFile.d.ts

@@ -1,4 +1,4 @@
-import { fileFormat } from 'core/flags/format.flags';
+import { fileFormat } from '../../apps/cli/internal/flags/format.flags';
 export declare class Specification {
     private readonly spec;
     private readonly filePath?;
@@ -13,7 +13,7 @@ export declare class Specification {
     text(): string;
     getFilePath(): string | undefined;
     getFileURL(): string | undefined;
-    getKind(): "file" | "url" | undefined;
+    getKind(): "url" | "file" | undefined;
     getSource(): string | undefined;
     toSourceString(): string;
     static fromFile(filepath: string): Promise<Specification>;

package/lib/{core → domains}/models/SpecificationFile.js

@@ -14,14 +14,14 @@ const path_1 = tslib_1.__importDefault(require("path"));
 const url_1 = require("url");
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
 const Context_1 = require("./Context");
-const specification_file_1 = require("../errors/specification-file");
-const context_error_1 = require("../errors/context-error");
+const specification_file_1 = require("../../errors/specification-file");
+const context_error_1 = require("../../errors/context-error");
 const https_proxy_agent_1 = require("https-proxy-agent");
 const { readFile, lstat } = fs_1.promises;
 const allowedFileNames = [
     'asyncapi.json',
     'asyncapi.yml',
-    'asyncapi.yaml'
+    'asyncapi.yaml',
 ];
 const TYPE_CONTEXT_NAME = 'context-name';
 const TYPE_FILE_PATH = 'file-path';
@@ -121,7 +121,9 @@ class Specification {
                 console.log(error);
                 throw new specification_file_1.ErrorLoadingSpec('url', targetUrl);
             }
-            return new Specification(yield (response === null || response === void 0 ? void 0 : response.text()), { fileURL: targetUrl });
+            return new Specification((yield (response === null || response === void 0 ? void 0 : response.text())), {
+                fileURL: targetUrl,
+            });
         });
     }
 }
@@ -143,6 +145,7 @@ exports.default = SpecificationFile;
 /* eslint-disable sonarjs/cognitive-complexity */
 function load(filePathOrContextName, loadType) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // NOSONAR
         try {
             if (filePathOrContextName) {
                 if (loadType === null || loadType === void 0 ? void 0 : loadType.file) {
@@ -251,7 +254,7 @@ function detectSpecFile() {
                 // We did our best...
             }
         })));
-        return existingFileNames.find(filename => filename !== undefined);
+        return existingFileNames.find((filename) => filename !== undefined);
     });
 }
 function retrieveFileFormat(content) {

package/lib/{core → domains}/models/Studio.js

@@ -4,7 +4,7 @@ exports.DEFAULT_PORT = void 0;
 exports.start = start;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
-const specification_file_1 = require("../errors/specification-file");
+const specification_file_1 = require("../../errors/specification-file");
 const http_1 = require("http");
 const ws_1 = require("ws");
 const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
@@ -20,6 +20,7 @@ exports.DEFAULT_PORT = 3210;
 function isValidFilePath(filePath) {
     return (0, fs_1.existsSync)(filePath);
 }
+// eslint-disable-next-line sonarjs/cognitive-complexity
 function start(filePath, port = exports.DEFAULT_PORT) {
     if (filePath && !isValidFilePath(filePath)) {
         throw new specification_file_1.SpecificationFileNotFound(filePath);
@@ -70,7 +71,7 @@ function start(filePath, port = exports.DEFAULT_PORT) {
         });
     });
     wsServer.on('close', (socket) => {
-        sockets.splice(sockets.findIndex(s => s === socket));
+        sockets.splice(sockets.findIndex((s) => s === socket));
     });
     app.prepare().then(() => {
         if (filePath) {
@@ -141,6 +142,5 @@ function getFileContent(filePath) {
     });
 }
 function saveFileContent(filePath, fileContent) {
-    writeFile(filePath, fileContent, { encoding: 'utf8' })
-        .catch(console.error);
+    writeFile(filePath, fileContent, { encoding: 'utf8' }).catch(console.error);
 }

package/lib/domains/services/archiver.service.d.ts

@@ -0,0 +1,17 @@
+import archiver, { Archiver } from 'archiver';
+import { Response } from 'express';
+/**
+ * Service wrapping the `archiver` module:
+    - easier zip creation
+    - adding proper `Content-Type` header
+    - easier adding an AsyncAPI document to the archive
+    - easier stream finalization
+ */
+export declare class ArchiverService {
+    createZip(res?: Response): archiver.Archiver;
+    appendDirectory(archive: Archiver, from: string, to: string): void;
+    appendAsyncAPIDocument(archive: Archiver, asyncapi: string, fileName?: string): void;
+    finalize(archive: Archiver): Promise<void>;
+    createTempDirectory(): Promise<string>;
+    removeTempDirectory(tmpDir: string): Promise<void>;
+}

package/lib/domains/services/archiver.service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiverService = void 0;
+const tslib_1 = require("tslib");
+const archiver_1 = tslib_1.__importDefault(require("archiver"));
+const retrieve_language_1 = require("../../utils/retrieve-language");
+const temp_dir_1 = require("../../utils/temp-dir");
+/**
+ * Service wrapping the `archiver` module:
+    - easier zip creation
+    - adding proper `Content-Type` header
+    - easier adding an AsyncAPI document to the archive
+    - easier stream finalization
+ */
+class ArchiverService {
+    createZip(res) {
+        const zip = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        if (res) {
+            zip.pipe(res);
+            res.attachment('asyncapi.zip');
+        }
+        return zip;
+    }
+    appendDirectory(archive, from, to) {
+        archive.directory(from, to);
+    }
+    appendAsyncAPIDocument(archive, asyncapi, fileName = 'asyncapi') {
+        asyncapi = JSON.stringify(asyncapi);
+        const language = (0, retrieve_language_1.retrieveLangauge)(asyncapi);
+        if (language === 'yaml') {
+            archive.append(asyncapi, { name: `${fileName}.yml` });
+        }
+        else {
+            archive.append(asyncapi, { name: `${fileName}.json` });
+        }
+    }
+    finalize(archive) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => {
+                // wait for end stream
+                archive.on('end', resolve);
+                archive.finalize();
+            });
+        });
+    }
+    createTempDirectory() {
+        return (0, temp_dir_1.createTempDirectory)();
+    }
+    removeTempDirectory(tmpDir) {
+        return (0, temp_dir_1.removeTempDirectory)(tmpDir);
+    }
+}
+exports.ArchiverService = ArchiverService;

package/lib/domains/services/base.service.d.ts

@@ -0,0 +1,6 @@
+import { ServiceResult } from '../../interfaces';
+export declare abstract class BaseService {
+    protected createSuccessResult<T>(data: T): ServiceResult<T>;
+    protected createErrorResult(error: string, diagnostics?: any[]): ServiceResult;
+    protected handleServiceError(error: any): Promise<ServiceResult>;
+}

package/lib/domains/services/base.service.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const tslib_1 = require("tslib");
+class BaseService {
+    createSuccessResult(data) {
+        return {
+            success: true,
+            data,
+        };
+    }
+    createErrorResult(error, diagnostics) {
+        return {
+            success: false,
+            error,
+            diagnostics,
+        };
+    }
+    handleServiceError(error) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return this.createErrorResult(errorMessage);
+        });
+    }
+}
+exports.BaseService = BaseService;

package/lib/domains/services/convert.service.d.ts

@@ -0,0 +1,12 @@
+import { ConversionOptions, ConversionResult, ServiceResult } from '../../interfaces';
+import { Specification } from '../models/SpecificationFile';
+import { BaseService } from './base.service';
+export declare class ConversionService extends BaseService {
+    /**
+     * Handles the conversion of AsyncAPI, Postman or OpenAPI documents based on the provided flags.
+     */
+    convertDocument(specFile: Specification, options: ConversionOptions): Promise<ServiceResult<ConversionResult>>;
+    handleLogging(specFile: Specification, flags: ConversionOptions): string;
+    private formatConvertedFile;
+    handleOutput(outputPath: string, convertedFileFormatted: string): Promise<void>;
+}

package/lib/domains/services/convert.service.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversionService = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const converter_1 = require("@asyncapi/converter");
+const picocolors_1 = require("picocolors");
+const fs_1 = require("fs");
+class ConversionService extends base_service_1.BaseService {
+    /**
+     * Handles the conversion of AsyncAPI, Postman or OpenAPI documents based on the provided flags.
+     */
+    convertDocument(specFile, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let convertedDocument;
+            switch (options.format) {
+                case 'asyncapi':
+                    convertedDocument = (0, converter_1.convert)((_a = specFile.text()) !== null && _a !== void 0 ? _a : '', options['target-version'] || '3.0.0');
+                    break;
+                case 'openapi':
+                    convertedDocument = (0, converter_1.convertOpenAPI)((_b = specFile.text()) !== null && _b !== void 0 ? _b : '', specFile.toJson().openapi, {
+                        perspective: options.perspective,
+                    });
+                    break;
+                case 'postman-collection':
+                    convertedDocument = (0, converter_1.convertPostman)((_c = specFile.text()) !== null && _c !== void 0 ? _c : '', '3.0.0', {
+                        perspective: options.perspective,
+                    });
+                    break;
+                default:
+                    return this.createErrorResult(`Unsupported conversion format: ${options.format}`);
+            }
+            return this.createSuccessResult({
+                convertedDocument: this.formatConvertedFile(convertedDocument),
+                originalFormat: options.format,
+            });
+        });
+    }
+    handleLogging(specFile, flags) {
+        const sourcePath = specFile.getFilePath() || specFile.getFileURL();
+        const targetVersion = flags['target-version'] || 'latest';
+        const outputMap = {
+            asyncapi: 'AsyncAPI document',
+            openapi: 'OpenAPI document',
+            'postman-collection': 'Postman Collection',
+        };
+        return `🎉 The ${outputMap[flags.format]} from ${(0, picocolors_1.cyan)(sourcePath)} has been successfully converted to AsyncAPI version ${(0, picocolors_1.green)(targetVersion)}!!`;
+    }
+    // Helper function to format the converted file
+    formatConvertedFile(convertedFile) {
+        return typeof convertedFile === 'object'
+            ? JSON.stringify(convertedFile, null, 4)
+            : convertedFile;
+    }
+    // Helper function to handle output
+    handleOutput(outputPath, convertedFileFormatted) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.writeFile(`${outputPath}`, convertedFileFormatted, {
+                encoding: 'utf8',
+            });
+        });
+    }
+}
+exports.ConversionService = ConversionService;

package/lib/domains/services/generator.service.d.ts

@@ -0,0 +1,15 @@
+import { GenerationOptions, GenerationResult, ServiceResult } from '../../interfaces';
+import { Specification } from '../models/SpecificationFile';
+import { BaseService } from './base.service';
+export declare class GeneratorService extends BaseService {
+    private defaultInteractive;
+    constructor(interactive?: boolean);
+    private templatesNotSupportingV3;
+    /**
+     * Verify that a given template support v3, if not, return the link to the issue that needs to be solved.
+     */
+    private verifyTemplateSupportForV3;
+    private checkV3NotSupported;
+    generate(asyncapi: Specification, template: string, output: string, options: GenerationOptions, genOption: any, interactive?: boolean): Promise<ServiceResult<GenerationResult>>;
+    generateUsingNewGenerator(asyncapi: Specification, template: string, output: string, options: any, genOption: any): Promise<ServiceResult<GenerationResult>>;
+}

package/lib/domains/services/generator.service.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorService = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const generator_1 = tslib_1.__importDefault(require("@asyncapi/generator"));
+const generator_v2_1 = tslib_1.__importDefault(require("generator-v2"));
+const prompts_1 = require("@clack/prompts");
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const picocolors_1 = require("picocolors");
+class GeneratorService extends base_service_1.BaseService {
+    constructor(interactive = false) {
+        super();
+        this.templatesNotSupportingV3 = {
+            '@asyncapi/minimaltemplate': 'some link', // For testing purpose
+            '@asyncapi/dotnet-nats-template': 'https://github.com/asyncapi/dotnet-nats-template/issues/384',
+            '@asyncapi/ts-nats-template': 'https://github.com/asyncapi/ts-nats-template/issues/545',
+            '@asyncapi/python-paho-template': 'https://github.com/asyncapi/python-paho-template/issues/189',
+            '@asyncapi/nodejs-ws-template': 'https://github.com/asyncapi/nodejs-ws-template/issues/294',
+            '@asyncapi/java-spring-cloud-stream-template': 'https://github.com/asyncapi/java-spring-cloud-stream-template/issues/336',
+            '@asyncapi/go-watermill-template': 'https://github.com/asyncapi/go-watermill-template/issues/243',
+            '@asyncapi/java-spring-template': 'https://github.com/asyncapi/java-spring-template/issues/308',
+            '@asyncapi/php-template': 'https://github.com/asyncapi/php-template/issues/191',
+        };
+        this.defaultInteractive = interactive;
+    }
+    /**
+     * Verify that a given template support v3, if not, return the link to the issue that needs to be solved.
+     */
+    verifyTemplateSupportForV3(template) {
+        if (this.templatesNotSupportingV3[`${template}`] !== undefined) {
+            return this.templatesNotSupportingV3[`${template}`];
+        }
+        return undefined;
+    }
+    checkV3NotSupported(asyncapi, template) {
+        if (asyncapi.isAsyncAPI3()) {
+            const v3IssueLink = this.verifyTemplateSupportForV3(template);
+            if (v3IssueLink !== undefined) {
+                return `${template} template does not support AsyncAPI v3 documents, please checkout ${v3IssueLink}`;
+            }
+        }
+    }
+    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 = this.defaultInteractive) {
+            const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
+            if (v3NotSupported) {
+                return this.createErrorResult(v3NotSupported);
+            }
+            const generator = new generator_1.default(template, output || path_1.default.resolve(os_1.default.tmpdir(), 'asyncapi-generator'), options);
+            const s = interactive
+                ? (0, prompts_1.spinner)()
+                : { start: () => null, stop: (string) => console.log(string) };
+            s.start('Generation in progress. Keep calm and wait a bit');
+            try {
+                yield generator.generateFromString(asyncapi.text(), Object.assign(Object.assign({}, genOption), { path: asyncapi }));
+            }
+            catch (err) {
+                console.log(err);
+                s.stop('Generation failed');
+                return this.createErrorResult(err.message, err.diagnostics);
+            }
+            s.stop(`${(0, picocolors_1.yellow)('Check out your shiny new generated files at ') + (0, picocolors_1.magenta)(output) + (0, picocolors_1.yellow)('.')}\n`);
+            return this.createSuccessResult({
+                success: true,
+                outputPath: output,
+            });
+        });
+    }
+    generateUsingNewGenerator(asyncapi, template, output, options, genOption) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
+            if (v3NotSupported) {
+                return this.createErrorResult(v3NotSupported);
+            }
+            const logs = [];
+            const generator = new generator_v2_1.default(template, output || path_1.default.resolve(os_1.default.tmpdir(), 'asyncapi-generator'), options);
+            try {
+                yield generator.generateFromString(asyncapi.text(), Object.assign(Object.assign({}, genOption), { path: asyncapi }));
+            }
+            catch (err) {
+                logs.push('Generation failed');
+                return this.createErrorResult(err.message, err.diagnostics);
+            }
+            logs.push(`${(0, picocolors_1.yellow)('Check out your shiny new generated files at ') + (0, picocolors_1.magenta)(output) + (0, picocolors_1.yellow)('.')}\n`);
+            return this.createSuccessResult({
+                success: true,
+                outputPath: output,
+                logs,
+            });
+        });
+    }
+}
+exports.GeneratorService = GeneratorService;

package/lib/domains/services/validation.service.d.ts

@@ -0,0 +1,54 @@
+import { BaseService } from './base.service';
+import { ValidationOptions, ValidationResult, ServiceResult, ParsedDocument, DiagnosticsFormat, SeverityKind } from '../../interfaces';
+import type { Diagnostic } from '@asyncapi/parser/cjs';
+import { Specification } from '../models/SpecificationFile';
+import { ParseOptions } from '@asyncapi/parser';
+import { ParserOptions } from '@asyncapi/parser/cjs/parser';
+export declare enum ValidationStatus {
+    INVALID = "invalid",
+    VALID = "valid"
+}
+export declare class ValidationService extends BaseService {
+    private parser;
+    constructor(parserOptions?: ParserOptions);
+    /**
+     * Determine validation status from diagnostics
+     */
+    private determineDiagnosticsStatus;
+    /**
+     * Parses an AsyncAPI document and returns the parsed result
+     */
+    parseDocument(specFile: Specification, parseOptions?: ParseOptions, options?: ValidationOptions): Promise<ServiceResult<ParsedDocument>>;
+    /**
+     * Validates an AsyncAPI document
+     */
+    validateDocument(specFile: Specification, options?: ValidationOptions): Promise<ServiceResult<ValidationResult>>;
+    /**
+     * Helper to build and register a custom parser with suppressed rules
+     */
+    private buildAndRegisterCustomParser;
+    /**
+     * Save validation diagnostics to file
+     */
+    saveDiagnosticsToFile(outputPath: string, format: DiagnosticsFormat, formatOutput: string): Promise<ServiceResult<string>>;
+    /**
+     * Generate governance message based on validation results
+     */
+    generateGovernanceMessage(sourceString: string, hasIssues: boolean, isFailSeverity: boolean): string;
+    /**
+     * Check if diagnostics contain failure severity issues
+     */
+    private hasFailSeverity;
+    /**
+     * Format validation diagnostics output
+     */
+    formatDiagnosticsOutput(diagnostics: Diagnostic[], format?: DiagnosticsFormat, failSeverity?: SeverityKind): string;
+    /**
+     * Format diagnostics in stylish format with severity grouping
+     */
+    private formatStylish;
+    /**
+     * Get colored severity title
+     */
+    private getSeverityTitle;
+}