ts-openapi-codegen 2.0.0-beta.9 → 2.1.0-beta.1

package/dist/core/semanticDiff/semanticDiffReportSchema.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.semanticDiffReportJsonSchema = void 0;
+exports.validateSemanticDiffReportSchema = validateSemanticDiffReportSchema;
+const json_schema_1 = require("json-schema");
+const analyzeOpenApiDiff_1 = require("./analyzeOpenApiDiff");
+exports.semanticDiffReportJsonSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        schemaVersion: {
+            type: 'string',
+            enum: [analyzeOpenApiDiff_1.SEMANTIC_DIFF_REPORT_SCHEMA_VERSION],
+            required: true,
+        },
+        summary: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                breaking: { type: 'integer', minimum: 0, required: true },
+                nonBreaking: { type: 'integer', minimum: 0, required: true },
+                informational: { type: 'integer', minimum: 0, required: true },
+            },
+        },
+        recommendation: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                semver: {
+                    type: 'string',
+                    enum: ['major', 'minor', 'patch'],
+                    required: true,
+                },
+                confidence: {
+                    type: 'string',
+                    enum: ['high', 'medium', 'low'],
+                    required: true,
+                },
+                reason: {
+                    type: 'string',
+                    minLength: 1,
+                    required: true,
+                },
+                reasons: {
+                    type: 'array',
+                    minItems: 1,
+                    required: true,
+                    items: {
+                        type: 'string',
+                        enum: [
+                            'HAS_BREAKING_CHANGES',
+                            'HAS_BACKWARD_COMPATIBLE_CHANGES',
+                            'HAS_INFORMATIONAL_ONLY_CHANGES',
+                            'NO_API_SURFACE_CHANGES',
+                        ],
+                    },
+                },
+            },
+        },
+        governance: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                summary: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        errors: { type: 'integer', minimum: 0, required: true },
+                        warnings: { type: 'integer', minimum: 0, required: true },
+                        info: { type: 'integer', minimum: 0, required: true },
+                    },
+                },
+                violations: {
+                    type: 'array',
+                    required: true,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            ruleId: { type: 'string', minLength: 1, required: true },
+                            severity: {
+                                type: 'string',
+                                enum: ['error', 'warning', 'info'],
+                                required: true,
+                            },
+                            message: { type: 'string', minLength: 1, required: true },
+                            path: { type: 'string', minLength: 1, required: true },
+                        },
+                    },
+                },
+            },
+        },
+        changes: {
+            type: 'array',
+            required: true,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    type: { type: 'string', minLength: 1, required: true },
+                    severity: {
+                        type: 'string',
+                        enum: ['breaking', 'non-breaking', 'informational'],
+                        required: true,
+                    },
+                    message: { type: 'string', minLength: 1, required: true },
+                    path: { type: 'string', minLength: 1, required: true },
+                },
+            },
+        },
+    },
+};
+/**
+ * Validates semantic diff report payload by JSON Schema contract.
+ */
+function validateSemanticDiffReportSchema(report) {
+    if (report === null || typeof report !== 'object') {
+        return {
+            valid: false,
+            errors: ['root: report must be an object'],
+        };
+    }
+    const result = (0, json_schema_1.validate)(report, exports.semanticDiffReportJsonSchema);
+    return {
+        valid: result.valid,
+        errors: result.errors.map(error => `${error.property}: ${error.message}`),
+    };
+}

package/dist/core/strict/__tests__/validateOpenApiStrict.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validateOpenApiStrict.test.d.ts.map

package/dist/core/strict/__tests__/validateOpenApiStrict.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateOpenApiStrict.test.d.ts","sourceRoot":"","sources":["../../../../src/core/strict/__tests__/validateOpenApiStrict.test.ts"],"names":[],"mappings":""}

package/dist/core/strict/__tests__/validateOpenApiStrict.test.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const validateOpenApiStrict_1 = require("../validateOpenApiStrict");
+(0, node_test_1.describe)('@unit: validateOpenApiStrict', () => {
+    (0, node_test_1.test)('reports unresolved refs, fallback media type, suspicious default response, and missing operationId', () => {
+        const openApi = {
+            paths: {
+                '/pets': {
+                    post: {
+                        requestBody: {
+                            content: {
+                                'text/plain': {
+                                    schema: { type: 'string' },
+                                },
+                            },
+                        },
+                        responses: {
+                            default: {
+                                description: 'ok',
+                                content: {
+                                    'application/problem+json': {
+                                        schema: { type: 'object' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi,
+            context: {
+                paths: () => ['/spec/main.yaml'],
+                get: () => ({
+                    components: {
+                        schemas: {
+                            Pet: {
+                                $ref: '#/components/schemas/Missing',
+                            },
+                        },
+                    },
+                }),
+                exists: () => false,
+            },
+        });
+        node_assert_1.default.strictEqual(report.summary.errors, 1);
+        node_assert_1.default.strictEqual(report.summary.warnings, 3);
+        node_assert_1.default.strictEqual(report.summary.info, 1);
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'UNRESOLVED_REF'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'CONTENT_MEDIA_TYPE_FALLBACK'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'SUSPICIOUS_DEFAULT_RESPONSE'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'MISSING_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'REQUIRE_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'NO_DEFAULT_WITHOUT_2XX'));
+    });
+    (0, node_test_1.test)('returns clean report when no strict issues found', () => {
+        const openApi = {
+            paths: {
+                '/pets': {
+                    get: {
+                        operationId: 'getPets',
+                        responses: {
+                            '200': {
+                                description: 'ok',
+                                content: {
+                                    'application/json': {
+                                        schema: { type: 'array' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi,
+            context: {
+                paths: () => ['/spec/main.yaml'],
+                get: () => ({}),
+                exists: () => true,
+            },
+        });
+        node_assert_1.default.deepStrictEqual(report.summary, {
+            errors: 0,
+            warnings: 0,
+            info: 0,
+        });
+        node_assert_1.default.deepStrictEqual(report.issues, []);
+        node_assert_1.default.deepStrictEqual(report.governance.violations, []);
+    });
+    (0, node_test_1.test)('includes preIssues from parser validation into final report', () => {
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi: { paths: {} },
+            context: {
+                paths: () => [],
+                get: () => ({}),
+                exists: () => true,
+            },
+            preIssues: [
+                {
+                    severity: 'error',
+                    code: 'OPENAPI_PARSER_VALIDATION_FAILED',
+                    message: 'Parser validation failed',
+                    path: '/spec/openapi.yaml',
+                },
+            ],
+        });
+        node_assert_1.default.strictEqual(report.summary.errors, 1);
+        node_assert_1.default.strictEqual(report.summary.warnings, 0);
+        node_assert_1.default.strictEqual(report.summary.info, 0);
+        node_assert_1.default.strictEqual(report.issues.length, 1);
+        node_assert_1.default.strictEqual(report.issues[0].code, 'OPENAPI_PARSER_VALIDATION_FAILED');
+        node_assert_1.default.deepStrictEqual(report.governance.violations, []);
+    });
+    (0, node_test_1.test)('applies governance config overrides in strict mode', () => {
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi: {
+                paths: {
+                    '/pets': {
+                        get: {
+                            responses: {
+                                default: {
+                                    description: 'fallback',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            context: {
+                paths: () => [],
+                get: () => ({}),
+                exists: () => true,
+            },
+            governanceConfig: {
+                rules: {
+                    REQUIRE_OPERATION_ID: {
+                        enabled: false,
+                    },
+                    NO_DEFAULT_WITHOUT_2XX: {
+                        severity: 'error',
+                    },
+                },
+            },
+        });
+        node_assert_1.default.ok(!report.governance.violations.some(violation => violation.ruleId === 'REQUIRE_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'NO_DEFAULT_WITHOUT_2XX' && violation.severity === 'error'));
+    });
+});

package/dist/core/strict/validateOpenApiStrict.d.ts

@@ -0,0 +1,43 @@
+import { Context } from '../Context';
+import { GovernancePolicyConfig, GovernanceReport } from '../governance/evaluateGovernanceRules';
+import { CommonOpenApi } from '../types/shared/CommonOpenApi.model';
+type StrictIssueSeverity = 'error' | 'warning' | 'info';
+type StrictIssue = {
+    severity: StrictIssueSeverity;
+    code: 'UNRESOLVED_REF' | 'CONTENT_MEDIA_TYPE_FALLBACK' | 'SUSPICIOUS_DEFAULT_RESPONSE' | 'MISSING_OPERATION_ID' | 'OPENAPI_PARSER_VALIDATION_FAILED';
+    message: string;
+    path: string;
+};
+type StrictSummary = {
+    errors: number;
+    warnings: number;
+    info: number;
+};
+export type StrictOpenApiReport = {
+    summary: StrictSummary;
+    governance: GovernanceReport;
+    issues: StrictIssue[];
+};
+type StrictValidationContext = Pick<Context, 'paths' | 'get' | 'exists'> & Partial<Pick<Context, 'getAllCanonicalRefs'>>;
+type ValidateOpenApiStrictParams = {
+    openApi: CommonOpenApi;
+    context: StrictValidationContext;
+    preIssues?: StrictIssue[];
+    governanceConfig?: GovernancePolicyConfig;
+};
+/**
+ * Runs SwaggerParser built-in `validate` and converts parser failure into strict issues.
+ * This check complements (but does not replace) custom strict diagnostics.
+ */
+export declare function validateWithSwaggerParser(inputPath: string): Promise<StrictIssue[]>;
+/**
+ * Runs strict OpenAPI diagnostics and returns a structured report.
+ */
+export declare function validateOpenApiStrict(params: ValidateOpenApiStrictParams): StrictOpenApiReport;
+/**
+ * Writes strict diagnostics report to a JSON file and returns absolute file path.
+ * Creates target directory if it does not exist.
+ */
+export declare function writeOpenApiStrictReport(report: StrictOpenApiReport, reportFilePath: string): Promise<string>;
+export {};
+//# sourceMappingURL=validateOpenApiStrict.d.ts.map

package/dist/core/strict/validateOpenApiStrict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateOpenApiStrict.d.ts","sourceRoot":"","sources":["../../../src/core/strict/validateOpenApiStrict.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAA0B,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AACzH,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,KAAK,mBAAmB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAExD,KAAK,WAAW,GAAG;IACf,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,GAAG,6BAA6B,GAAG,6BAA6B,GAAG,sBAAsB,GAAG,kCAAkC,CAAC;IACrJ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,aAAa,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,uBAAuB,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC,GACpE,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAElD,KAAK,2BAA2B,GAAG;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,uBAAuB,CAAC;IACjC,SAAS,CAAC,EAAE,WAAW,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AAqNF;;;GAGG;AACH,wBAAsB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAiBzF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,2BAA2B,GAAG,mBAAmB,CAe9F;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAanH"}

package/dist/core/strict/validateOpenApiStrict.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWithSwaggerParser = validateWithSwaggerParser;
+exports.validateOpenApiStrict = validateOpenApiStrict;
+exports.writeOpenApiStrictReport = writeOpenApiStrictReport;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const path_1 = __importDefault(require("path"));
+const fileSystemHelpers_1 = require("../../common/utils/fileSystemHelpers");
+const format_1 = require("../../common/utils/format");
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const getContent_1 = require("../api/v3/parser/getContent");
+const evaluateGovernanceRules_1 = require("../governance/evaluateGovernanceRules");
+const HTTP_METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+/**
+ * Normalizes a media type value by:
+ * 1) removing parameters after `;`
+ * 2) trimming surrounding spaces
+ * 3) converting to lowercase.
+ */
+function normalizeMediaType(mediaType) {
+    return mediaType.split(';')[0].trim().toLowerCase();
+}
+/**
+ * Checks whether a response code key is an explicit success code.
+ * Supports exact `2xx` numeric codes and OpenAPI range form `2XX`.
+ */
+function isSuccessResponseCode(responseCode) {
+    return /^\s*2\d\d\s*$/.test(responseCode) || /^\s*2xx\s*$/i.test(responseCode);
+}
+/**
+ * Builds aggregated counters for report summary from collected issues.
+ */
+function createSummary(issues) {
+    return issues.reduce((summary, issue) => {
+        if (issue.severity === 'error') {
+            summary.errors += 1;
+        }
+        else if (issue.severity === 'warning') {
+            summary.warnings += 1;
+        }
+        else {
+            summary.info += 1;
+        }
+        return summary;
+    }, { errors: 0, warnings: 0, info: 0 });
+}
+/**
+ * Extracts source file path from a canonical ref.
+ * Example: `/spec/pet.yaml#/components/schemas/Pet` -> `/spec/pet.yaml`.
+ */
+function getSourceFileFromRef(ref) {
+    return ref.split('#')[0] || ref;
+}
+/**
+ * Returns refs to traverse for strict `$ref` checks.
+ *
+ * Priority:
+ * 1) Canonical refs from `context.getAllCanonicalRefs()` when available.
+ * 2) Fallback to file-level refs from `context.paths()`.
+ */
+function getSchemaTraversalRefs(context) {
+    if (typeof context.getAllCanonicalRefs === 'function') {
+        const canonicalRefs = context.getAllCanonicalRefs();
+        if (canonicalRefs.length > 0) {
+            return canonicalRefs;
+        }
+    }
+    return context.paths();
+}
+/**
+ * Traverses resolved schemas and collects diagnostics for unresolved `$ref`.
+ *
+ * Uses Context methods:
+ * - `getAllCanonicalRefs()` to iterate canonical refs with fragments (when available)
+ * - `paths()` to iterate source schema files
+ * - `get()` to load schema data
+ * - `exists()` to validate each discovered `$ref`
+ *
+ * Duplicate diagnostics are removed via a local dedupe set.
+ */
+function collectUnresolvedRefIssues(context) {
+    const issues = [];
+    const dedupe = new Set();
+    const walk = (node, sourceFile, pathSegments) => {
+        if (!node || typeof node !== 'object') {
+            return;
+        }
+        const objectNode = node;
+        if (typeof objectNode.$ref === 'string') {
+            const ref = objectNode.$ref;
+            const isRefExists = context.exists(ref, sourceFile);
+            if (!isRefExists) {
+                const issuePath = `${sourceFile} ${pathSegments.join('.') || '$'}.$ref`;
+                const dedupeKey = `${sourceFile}|${issuePath}|${ref}`;
+                if (!dedupe.has(dedupeKey)) {
+                    dedupe.add(dedupeKey);
+                    issues.push({
+                        severity: 'error',
+                        code: 'UNRESOLVED_REF',
+                        message: `Unresolved $ref: ${ref}`,
+                        path: issuePath,
+                    });
+                }
+            }
+        }
+        if (Array.isArray(node)) {
+            node.forEach((item, index) => walk(item, sourceFile, [...pathSegments, `[${index}]`]));
+            return;
+        }
+        for (const [key, value] of Object.entries(objectNode)) {
+            walk(value, sourceFile, [...pathSegments, key]);
+        }
+    };
+    const traversalRefs = getSchemaTraversalRefs(context);
+    for (const traversalRef of traversalRefs) {
+        try {
+            const schema = context.get(traversalRef);
+            const sourceFile = getSourceFileFromRef(traversalRef);
+            walk(schema, sourceFile, []);
+        }
+        catch {
+            // Ignore non-schema technical refs.
+        }
+    }
+    return issues;
+}
+/**
+ * Collects operation-level diagnostics:
+ * - `info` for missing `operationId`
+ * - `warning` for fallback media type selection
+ * - `warning` for `default` response without explicit `2xx`.
+ */
+function collectOperationIssues(openApi) {
+    const issues = [];
+    const paths = openApi.paths;
+    for (const [routePath, pathItem] of Object.entries(paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem?.[method];
+            if (!operation || typeof operation !== 'object') {
+                continue;
+            }
+            const operationPath = `${routePath} ${method.toUpperCase()}`;
+            if (!operation.operationId) {
+                issues.push({
+                    severity: 'info',
+                    code: 'MISSING_OPERATION_ID',
+                    message: 'Operation does not define operationId.',
+                    path: operationPath,
+                });
+            }
+            const requestBodyContent = operation?.requestBody?.content;
+            if (requestBodyContent && typeof requestBodyContent === 'object') {
+                const selectedContent = (0, getContent_1.getContent)(requestBodyContent);
+                if (selectedContent && normalizeMediaType(selectedContent.mediaType) !== 'application/json') {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'CONTENT_MEDIA_TYPE_FALLBACK',
+                        message: `No application/json found, fallback media type selected: ${selectedContent.mediaType}`,
+                        path: `${operationPath} requestBody.content`,
+                    });
+                }
+            }
+            const responses = operation?.responses;
+            if (responses && typeof responses === 'object') {
+                const responseCodes = Object.keys(responses);
+                const hasDefaultResponse = responseCodes.includes('default');
+                const hasExplicitSuccessResponse = responseCodes.some(isSuccessResponseCode);
+                if (hasDefaultResponse && !hasExplicitSuccessResponse) {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'SUSPICIOUS_DEFAULT_RESPONSE',
+                        message: 'Default response is used without an explicit 2xx response.',
+                        path: `${operationPath} responses.default`,
+                    });
+                }
+                for (const responseCode of responseCodes) {
+                    const response = responses[responseCode];
+                    const responseContent = response?.content;
+                    if (!responseContent || typeof responseContent !== 'object') {
+                        continue;
+                    }
+                    const selectedContent = (0, getContent_1.getContent)(responseContent);
+                    if (selectedContent && normalizeMediaType(selectedContent.mediaType) !== 'application/json') {
+                        issues.push({
+                            severity: 'warning',
+                            code: 'CONTENT_MEDIA_TYPE_FALLBACK',
+                            message: `No application/json found, fallback media type selected: ${selectedContent.mediaType}`,
+                            path: `${operationPath} responses.${responseCode}.content`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Runs SwaggerParser built-in `validate` and converts parser failure into strict issues.
+ * This check complements (but does not replace) custom strict diagnostics.
+ */
+async function validateWithSwaggerParser(inputPath) {
+    const parser = new swagger_parser_1.default();
+    const absoluteInputPath = (0, pathHelpers_1.resolveHelper)(inputPath);
+    try {
+        await parser.validate(absoluteInputPath);
+        return [];
+    }
+    catch (error) {
+        return [
+            {
+                severity: 'error',
+                code: 'OPENAPI_PARSER_VALIDATION_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                path: absoluteInputPath,
+            },
+        ];
+    }
+}
+/**
+ * Runs strict OpenAPI diagnostics and returns a structured report.
+ */
+function validateOpenApiStrict(params) {
+    const { openApi, context, preIssues = [], governanceConfig } = params;
+    const issues = [...preIssues, ...collectUnresolvedRefIssues(context), ...collectOperationIssues(openApi)];
+    const governance = (0, evaluateGovernanceRules_1.evaluateGovernanceRules)({
+        openApi,
+        allowBreaking: true,
+        governanceConfig,
+    });
+    return {
+        summary: createSummary(issues),
+        governance,
+        issues,
+    };
+}
+/**
+ * Writes strict diagnostics report to a JSON file and returns absolute file path.
+ * Creates target directory if it does not exist.
+ */
+async function writeOpenApiStrictReport(report, reportFilePath) {
+    const resolvedReportPath = (0, pathHelpers_1.resolveHelper)(process.cwd(), reportFilePath);
+    const reportDir = path_1.default.dirname(resolvedReportPath);
+    const isReportDirExists = await fileSystemHelpers_1.fileSystemHelpers.exists(reportDir);
+    if (!isReportDirExists) {
+        await fileSystemHelpers_1.fileSystemHelpers.mkdir(reportDir);
+    }
+    const reportContent = await (0, format_1.format)(JSON.stringify(report), 'json');
+    await fileSystemHelpers_1.fileSystemHelpers.writeFile(resolvedReportPath, reportContent);
+    return resolvedReportPath;
+}

package/dist/core/types/base/ClientArtifacts.model.d.ts

@@ -8,5 +8,7 @@ export type ClientArtifacts = {
     models: ExportedModel[];
     schemas: ExportedModel[];
     services: ExportedService[];
+    modelsMode?: import('../enums/ModelsMode.enum').ModelsMode;
+    modelsPackage?: string;
 };
 //# sourceMappingURL=ClientArtifacts.model.d.ts.map

package/dist/core/types/base/ClientArtifacts.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClientArtifacts.model.d.ts","sourceRoot":"","sources":["../../../../src/core/types/base/ClientArtifacts.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAA"}
+{"version":3,"file":"ClientArtifacts.model.d.ts","sourceRoot":"","sources":["../../../../src/core/types/base/ClientArtifacts.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,0BAA0B,EAAE,UAAU,CAAC;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAA"}

package/dist/core/types/base/Templates.model.d.ts

@@ -11,7 +11,8 @@ export interface Templates {
     exports: {
         client: Handlebars.TemplateDelegate;
         model: Handlebars.TemplateDelegate;
-        schema: Handlebars.TemplateDelegate | undefined;
+        models: Handlebars.TemplateDelegate;
+        schema: Handlebars.TemplateDelegate;
         service: Handlebars.TemplateDelegate;
     };
     core: {
@@ -19,6 +20,8 @@ export interface Templates {
         apiError: Handlebars.TemplateDelegate;
         apiRequestOptions: Handlebars.TemplateDelegate;
         apiResult: Handlebars.TemplateDelegate;
+        baseDto: Handlebars.TemplateDelegate;
+        dtoUtils: Handlebars.TemplateDelegate;
         request: Handlebars.TemplateDelegate;
         cancelablePromise: Handlebars.TemplateDelegate;
         httpStatusCode: Handlebars.TemplateDelegate;

package/dist/core/types/base/Templates.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Templates.model.d.ts","sourceRoot":"","sources":["../../../../src/core/types/base/Templates.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AAEjD,MAAM,WAAW,SAAS;IACtB,OAAO,EAAE;QACL,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAClC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAClC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACrC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACzC,CAAC;IACF,OAAO,EAAE;QACL,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,KAAK,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAChD,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACxC,CAAC;IACF,IAAI,EAAE;QACF,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACtC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACtC,iBAAiB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC/C,SAAS,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACvC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACrC,iBAAiB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC/C,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC5C,eAAe,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC7C,qBAAqB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACnD,YAAY,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC1C,mBAAmB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACjD,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACjD,CAAC;CACL"}
+{"version":3,"file":"Templates.model.d.ts","sourceRoot":"","sources":["../../../../src/core/types/base/Templates.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AAEjD,MAAM,WAAW,SAAS;IACtB,OAAO,EAAE;QACL,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAClC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAClC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACrC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACzC,CAAC;IACF,OAAO,EAAE;QACL,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,KAAK,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACpC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACxC,CAAC;IACF,IAAI,EAAE;QACF,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACtC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACtC,iBAAiB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC/C,SAAS,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACvC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACrC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACtC,OAAO,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACrC,iBAAiB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC/C,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC5C,eAAe,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC7C,qBAAqB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACnD,YAAY,EAAE,UAAU,CAAC,gBAAgB,CAAC;QAC1C,mBAAmB,EAAE,UAAU,CAAC,gBAAgB,CAAC;QACjD,gBAAgB,EAAE,UAAU,CAAC,gBAAgB,CAAC;KACjD,CAAC;CACL"}

package/dist/core/types/enums/EmptySchemaStrategy.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum EmptySchemaStrategy {
+    SEMANTIC = "semantic",
+    SKIP = "skip",
+    KEEP = "keep"
+}
+//# sourceMappingURL=EmptySchemaStrategy.enum.d.ts.map

package/dist/core/types/enums/EmptySchemaStrategy.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptySchemaStrategy.enum.d.ts","sourceRoot":"","sources":["../../../../src/core/types/enums/EmptySchemaStrategy.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,mBAAmB;IAC3B,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,IAAI,SAAS;CAChB"}

package/dist/core/types/enums/EmptySchemaStrategy.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptySchemaStrategy = void 0;
+var EmptySchemaStrategy;
+(function (EmptySchemaStrategy) {
+    EmptySchemaStrategy["SEMANTIC"] = "semantic";
+    EmptySchemaStrategy["SKIP"] = "skip";
+    EmptySchemaStrategy["KEEP"] = "keep";
+})(EmptySchemaStrategy || (exports.EmptySchemaStrategy = EmptySchemaStrategy = {}));

package/dist/core/types/enums/ModelsMode.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ModelsMode {
+    INTERFACES = "interfaces",
+    CLASSES = "classes"
+}
+//# sourceMappingURL=ModelsMode.enum.d.ts.map

package/dist/core/types/enums/ModelsMode.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelsMode.enum.d.ts","sourceRoot":"","sources":["../../../../src/core/types/enums/ModelsMode.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU;IAClB,UAAU,eAAe;IACzB,OAAO,YAAY;CACtB"}