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

package/lib/apps/api/controllers/convert.controller.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const convert_service_1 = require("../../../domains/services/convert.service");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+/**
+ * Controller which exposes the Convert functionality
+ */
+class ConvertController {
+    constructor() {
+        this.basepath = '/convert';
+        this.conversionService = new convert_service_1.ConversionService();
+    }
+    convert(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const options = req.body;
+                const specFile = new SpecificationFile_1.Specification(typeof options.source === 'string'
+                    ? options.source
+                    : JSON.stringify(options.source));
+                const result = yield this.conversionService.convertDocument(specFile, options);
+                if (!result.success) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'conversion-error',
+                        title: 'Conversion failed',
+                        status: 400,
+                        detail: result.error,
+                    }));
+                }
+                res.status(200).json({
+                    converted: (_a = result.data) === null || _a === void 0 ? void 0 : _a.convertedDocument,
+                    sourceFormat: (_b = result.data) === null || _b === void 0 ? void 0 : _b.originalFormat,
+                });
+            }
+            catch (err) {
+                if (err instanceof problem_exception_1.ProblemException) {
+                    return next(err);
+                }
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal server error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(this.basepath, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['source'],
+                condition: (req) => {
+                    const body = req.body;
+                    return body.format === 'asyncapi';
+                },
+            }), this.convert.bind(this));
+            return router;
+        });
+    }
+}
+exports.ConvertController = ConvertController;

package/lib/apps/api/controllers/diff.controller.d.ts

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class DiffController implements Controller {
+    basepath: string;
+    private diff;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/diff.controller.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const diff_1 = require("@asyncapi/diff");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const problem_exception_1 = require("../exceptions/problem.exception");
+class DiffController {
+    constructor() {
+        this.basepath = '/diff';
+    }
+    diff(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { asyncapis } = req.body;
+            try {
+                const output = (0, diff_1.diff)(asyncapis[0], asyncapis[1]).getOutput();
+                res.status(200).json({ diff: output });
+            }
+            catch (err) {
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-diff-error',
+                    title: 'Internal Diff error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(this.basepath, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapis'],
+            }), this.diff.bind(this));
+            return router;
+        });
+    }
+}
+exports.DiffController = DiffController;

package/lib/apps/api/controllers/docs.controller.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class DocsController implements Controller {
+    basepath: string;
+    boot(): Router;
+}

package/lib/apps/api/controllers/docs.controller.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocsController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const redoc_express_1 = tslib_1.__importDefault(require("redoc-express"));
+const constants_1 = require("../constants");
+class DocsController {
+    constructor() {
+        this.basepath = '/docs';
+    }
+    boot() {
+        const router = (0, express_1.Router)();
+        router.get(`${this.basepath}/openapi.yaml`, (_, res) => {
+            res.sendFile('openapi.yaml', { root: '.' });
+        });
+        router.get(this.basepath, (0, redoc_express_1.default)({
+            title: 'OpenAPI Documentation',
+            specUrl: `/${constants_1.API_VERSION}${this.basepath}/openapi.yaml`,
+        }));
+        return router;
+    }
+}
+exports.DocsController = DocsController;

package/lib/apps/api/controllers/generate.controller.d.ts

@@ -0,0 +1,22 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Generator functionality
+ */
+export declare class GenerateController implements Controller {
+    basepath: string;
+    private archiverService;
+    private generatorService;
+    private ajv;
+    private generate;
+    private validateTemplateParameters;
+    /**
+     * Retrieve proper AJV's validator function, create or reuse it.
+     */
+    getAjvValidator(templateName: string): Promise<import("ajv/dist/types").AnyValidateFunction<unknown> | undefined>;
+    /**
+     * Serialize template parameters. Read all parameters from template's package.json and create a proper JSON Schema for validating parameters.
+     */
+    serializeTemplateParameters(templateName: string): Promise<object | undefined>;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/generate.controller.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateController = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const express_1 = require("express");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const archiver_service_1 = require("../../../domains/services/archiver.service");
+const generator_service_1 = require("../../../domains/services/generator.service");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+/**
+ * Controller which exposes the Generator functionality
+ */
+class GenerateController {
+    constructor() {
+        this.basepath = '/generate';
+        this.archiverService = new archiver_service_1.ArchiverService();
+        this.generatorService = new generator_service_1.GeneratorService();
+    }
+    generate(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // try {
+            //   await this.validateTemplateParameters(req);
+            // } catch (err) {
+            //   return next(err);
+            // }
+            const zip = this.archiverService.createZip(res);
+            let tmpDir;
+            try {
+                tmpDir = yield this.archiverService.createTempDirectory();
+                const { asyncapi, template, parameters } = req.body;
+                const options = {
+                    forceWrite: true,
+                    templateParams: parameters,
+                };
+                const generateFunc = this.generatorService.generate.bind(this.generatorService);
+                try {
+                    const result = yield generateFunc(new SpecificationFile_1.Specification(typeof asyncapi === 'object' ? JSON.stringify(asyncapi) : asyncapi), template, tmpDir, options, {}, true);
+                    if (!result.success) {
+                        return next(new problem_exception_1.ProblemException({
+                            type: 'generation-error',
+                            title: 'Generation Error',
+                            status: 500,
+                            detail: result.error || 'An error occurred during generation.',
+                        }));
+                    }
+                }
+                catch (genErr) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'internal-generator-error',
+                        title: 'Internal Generator error',
+                        status: 500,
+                        detail: genErr.message,
+                    }));
+                }
+                this.archiverService.appendDirectory(zip, tmpDir, 'template');
+                this.archiverService.appendAsyncAPIDocument(zip, asyncapi);
+                res.status(200);
+                return yield this.archiverService.finalize(zip);
+            }
+            catch (err) {
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal server error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+            finally {
+                if (tmpDir) {
+                    // Remove the temporary directory after the response is sent
+                    // to avoid leaving temporary files on the server.
+                    yield this.archiverService.removeTempDirectory(tmpDir);
+                }
+            }
+        });
+    }
+    validateTemplateParameters(req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { template, parameters } = req.body;
+            const validate = yield this.getAjvValidator(template);
+            if (!validate) {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-template',
+                    title: 'Invalid Generator Template',
+                    status: 422,
+                    detail: `Template ${template} is not valid or does not exist.`,
+                });
+            }
+            const valid = validate(parameters || {});
+            const errors = validate.errors && [...validate.errors];
+            if (valid === false) {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-template-parameters',
+                    title: 'Invalid Generator Template parameters',
+                    status: 422,
+                    validationErrors: errors,
+                });
+            }
+        });
+    }
+    /**
+     * Retrieve proper AJV's validator function, create or reuse it.
+     */
+    getAjvValidator(templateName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.ajv) {
+                throw new Error('AJV instance is not initialized');
+            }
+            let validate = this.ajv.getSchema(templateName);
+            if (!validate) {
+                this.ajv.addSchema((yield this.serializeTemplateParameters(templateName)) || {}, templateName);
+                validate = this.ajv.getSchema(templateName);
+            }
+            return validate;
+        });
+    }
+    /**
+     * Serialize template parameters. Read all parameters from template's package.json and create a proper JSON Schema for validating parameters.
+     */
+    serializeTemplateParameters(templateName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const pathToPackageJSON = path_1.default.join(__dirname, `../../../../node_modules/${templateName}/package.json`);
+            const packageJSONContent = yield fs_1.default.promises.readFile(pathToPackageJSON, 'utf-8');
+            const packageJSON = JSON.parse(packageJSONContent);
+            if (!packageJSON) {
+                return;
+            }
+            const generator = packageJSON.generator;
+            if (!generator || !generator.parameters) {
+                return;
+            }
+            const parameters = generator.parameters || {};
+            const required = [];
+            for (const parameter in parameters) {
+                // at the moment all parameters have to be passed to the Generator instance as string
+                parameters[String(parameter)].type = 'string';
+                if (parameters[String(parameter)].required) {
+                    required.push(parameter);
+                }
+                delete parameters[String(parameter)].required;
+            }
+            return {
+                $schema: 'http://json-schema.org/draft-07/schema#',
+                type: 'object',
+                properties: parameters,
+                required,
+                // don't allow non supported properties
+                additionalProperties: false,
+            };
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.ajv = new ajv_1.default({
+                inlineRefs: true,
+                allErrors: true,
+                schemaId: 'id',
+                logger: false,
+            });
+            const router = (0, express_1.Router)();
+            router.post(`${this.basepath}`, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapi'],
+            }), this.generate.bind(this));
+            return router;
+        });
+    }
+}
+exports.GenerateController = GenerateController;

package/lib/apps/api/controllers/help.controller.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class HelpController implements Controller {
+    basepath: string;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/help.controller.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const app_openapi_1 = require("../../../utils/app-openapi");
+const getCommandsFromRequest = (req) => {
+    return req.params.command
+        ? req.params.command.split('/').filter((cmd) => cmd.trim())
+        : [];
+};
+const isKeyValid = (key, obj) => {
+    return Object.keys(obj).includes(key);
+};
+const getPathKeysMatchingCommands = (commands, pathKeys) => {
+    if (!Array.isArray(pathKeys) ||
+        !pathKeys.every((key) => typeof key === 'string')) {
+        return undefined;
+    }
+    return pathKeys.find((pathKey) => {
+        const pathParts = pathKey.split('/').filter((part) => part !== '');
+        return pathParts.every((pathPart, i) => {
+            const command = commands[Number(i)];
+            return pathPart === command || pathPart.startsWith('{');
+        });
+    });
+};
+const getFullRequestBodySpec = (operationDetails) => {
+    return isKeyValid('requestBody', operationDetails)
+        ? operationDetails.requestBody.content['application/json'].schema
+        : null;
+};
+const buildResponseObject = (matchedPathKey, method, operationDetails, requestBodySchema) => {
+    return {
+        command: matchedPathKey,
+        method: method.toUpperCase(),
+        summary: operationDetails.summary || '',
+        requestBody: requestBodySchema,
+    };
+};
+class HelpController {
+    constructor() {
+        this.basepath = '/help';
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.get('/help/:command*?', (req, res, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const commands = getCommandsFromRequest(req);
+                let openapiSpec;
+                try {
+                    openapiSpec = yield (0, app_openapi_1.getAppOpenAPI)();
+                }
+                catch (err) {
+                    return next(err);
+                }
+                if (commands.length === 0) {
+                    const routes = isKeyValid('paths', openapiSpec)
+                        ? Object.keys(openapiSpec.paths).map((path) => ({
+                            command: path.replace(/^\//, ''),
+                            url: `${this.basepath}${path}`,
+                        }))
+                        : [];
+                    return res.json(routes);
+                }
+                const pathKeys = isKeyValid('paths', openapiSpec)
+                    ? Object.keys(openapiSpec.paths)
+                    : [];
+                const matchedPathKey = getPathKeysMatchingCommands(commands, pathKeys);
+                if (!matchedPathKey) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'invalid-asyncapi-command',
+                        title: 'Invalid AsyncAPI Command',
+                        status: 404,
+                        detail: 'The given AsyncAPI command is not valid.',
+                    }));
+                }
+                const pathInfo = isKeyValid(matchedPathKey, openapiSpec.paths)
+                    ? openapiSpec.paths[String(matchedPathKey)]
+                    : undefined;
+                const method = commands.length > 1 ? 'get' : 'post';
+                const operationDetails = isKeyValid(method, pathInfo)
+                    ? pathInfo[String(method)]
+                    : undefined;
+                if (!operationDetails) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'invalid-asyncapi-command',
+                        title: 'Invalid AsyncAPI Command',
+                        status: 404,
+                        detail: 'The given AsyncAPI command is not valid.',
+                    }));
+                }
+                const requestBodySchema = getFullRequestBodySpec(operationDetails);
+                return res.json(buildResponseObject(matchedPathKey, method, operationDetails, requestBodySchema));
+            }));
+            return router;
+        });
+    }
+}
+exports.HelpController = HelpController;

package/lib/apps/api/controllers/parse.controller.d.ts

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Parser functionality, to parse the AsyncAPI document.
+ */
+export declare class ParseController implements Controller {
+    basepath: string;
+    private parse;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/parse.controller.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+/**
+ * Controller which exposes the Parser functionality, to parse the AsyncAPI document.
+ */
+class ParseController {
+    constructor() {
+        this.basepath = '/parse';
+    }
+    parse(req, res) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const stringified = JSON.stringify((_a = req.asyncapi) === null || _a === void 0 ? void 0 : _a.parsedDocument);
+            res.status(200).json({
+                parsed: stringified,
+            });
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(`${this.basepath}`, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapi'],
+            }), this.parse.bind(this));
+            return router;
+        });
+    }
+}
+exports.ParseController = ParseController;

package/lib/apps/api/controllers/validate.controller.d.ts

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Parser functionality, to validate the AsyncAPI document.
+ */
+export declare class ValidateController implements Controller {
+    basepath: string;
+    private validate;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/validate.controller.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+/**
+ * Controller which exposes the Parser functionality, to validate the AsyncAPI document.
+ */
+class ValidateController {
+    constructor() {
+        this.basepath = '/validate';
+    }
+    validate(req, res) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            if ((_b = (_a = req.asyncapi) === null || _a === void 0 ? void 0 : _a.parsedDocuments) === null || _b === void 0 ? void 0 : _b.length) {
+                const results = ((_c = req.asyncapi.validationResults) === null || _c === void 0 ? void 0 : _c.map((result) => ({
+                    status: result.status,
+                    asyncapi: result.document,
+                    diagnostics: result.diagnostics,
+                    score: result.score,
+                }))) || [];
+                res.status(200).json({
+                    results,
+                });
+            }
+            else {
+                res.status(200).json({
+                    status: (_e = (_d = req.asyncapi) === null || _d === void 0 ? void 0 : _d.validationResult) === null || _e === void 0 ? void 0 : _e.status,
+                    asyncapi: (_g = (_f = req.asyncapi) === null || _f === void 0 ? void 0 : _f.validationResult) === null || _g === void 0 ? void 0 : _g.document,
+                    diagnostics: (_j = (_h = req.asyncapi) === null || _h === void 0 ? void 0 : _h.validationResult) === null || _j === void 0 ? void 0 : _j.diagnostics,
+                    score: (_l = (_k = req.asyncapi) === null || _k === void 0 ? void 0 : _k.validationResult) === null || _l === void 0 ? void 0 : _l.score,
+                });
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(`${this.basepath}`, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapi'],
+            }), this.validate.bind(this));
+            return router;
+        });
+    }
+}
+exports.ValidateController = ValidateController;

package/lib/apps/api/controllers/version.controller.d.ts

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class VersionController implements Controller {
+    basepath: string;
+    private startTime;
+    private getPackageInfo;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/version.controller.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionController = void 0;
+const tslib_1 = require("tslib");
+const os = tslib_1.__importStar(require("os"));
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const express_1 = require("express");
+class VersionController {
+    constructor() {
+        this.basepath = '/version';
+        this.startTime = new Date();
+    }
+    getPackageInfo() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const packagePath = path.join(process.cwd(), 'package.json');
+                return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            }
+            catch (_a) {
+                return {};
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.get(`${this.basepath}`, (req, res, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    const packageJson = yield this.getPackageInfo();
+                    const versionInfo = {
+                        // Core version information
+                        version: packageJson.version || process.env.npm_package_version || 'unknown',
+                        name: packageJson.name || 'AsyncAPI CLI API',
+                        description: packageJson.description || 'All in one CLI for all AsyncAPI tools',
+                        // Runtime information
+                        runtime: {
+                            node: process.version,
+                            environment: process.env.NODE_ENV || 'development',
+                            platform: os.platform(),
+                            arch: os.arch(),
+                            uptime: `${Math.floor((Date.now() - this.startTime.getTime()) / 1000)} seconds`,
+                            startTime: this.startTime.toISOString()
+                        },
+                        // Repository information
+                        repository: {
+                            url: packageJson.homepage || ((_a = packageJson.repository) === null || _a === void 0 ? void 0 : _a.url) || 'https://github.com/asyncapi/cli',
+                            bugs: packageJson.bugs || 'https://github.com/asyncapi/cli/issues',
+                            license: packageJson.license || 'Apache-2.0'
+                        },
+                        // API metadata
+                        api: {
+                            basePath: this.basepath,
+                            timestamp: new Date().toISOString(),
+                            health: 'ok'
+                        }
+                    };
+                    res.json(versionInfo);
+                }
+                catch (err) {
+                    return next(err);
+                }
+            }));
+            return router;
+        });
+    }
+}
+exports.VersionController = VersionController;

package/lib/apps/api/exceptions/problem.exception.d.ts

@@ -0,0 +1,14 @@
+export interface ProblemExceptionProps {
+    status: number;
+    [key: string]: any;
+}
+declare const ProblemException_base: {
+    new (problem: import("@asyncapi/problem").ProblemBase & ProblemExceptionProps, options?: import("@asyncapi/problem").ProblemOptions): import("@asyncapi/problem").Problem<ProblemExceptionProps>;
+    createType(type: string): string;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ProblemException extends ProblemException_base {
+}
+export {};