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

package/dist/core/semanticDiff/__tests__/analyzeOpenApiDiff.test.js

@@ -0,0 +1,537 @@
+"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 analyzeOpenApiDiff_1 = require("../analyzeOpenApiDiff");
+(0, node_test_1.describe)('@unit: analyzeOpenApiDiff', () => {
+    (0, node_test_1.test)('detects breaking model and operation removals', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/pets': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    Pet: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                        },
+                        required: ['id'],
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.strictEqual(report.schemaVersion, '1.1.0');
+        node_assert_1.default.ok(report.summary.breaking >= 2);
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.removed'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'operation.removed'));
+    });
+    (0, node_test_1.test)('detects property required/type changes and enum changes', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                            role: { enum: ['user', 'admin'] },
+                        },
+                        required: ['age'],
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'integer' },
+                            role: { enum: ['admin'] },
+                        },
+                        required: [],
+                    },
+                },
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.type.changed' && change.severity === 'breaking'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.required.changed' && change.severity === 'non-breaking'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.type.changed' && change.path.includes('/role')));
+    });
+    (0, node_test_1.test)('detects non-breaking additions', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    Ping: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                            '201': { description: 'created' },
+                        },
+                    },
+                },
+                '/pong': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    Ping: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'string' },
+                            meta: { type: 'string' },
+                        },
+                    },
+                    Pong: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(report.summary.nonBreaking >= 3);
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.added'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'operation.added'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'operation.response.success.added'));
+    });
+    (0, node_test_1.test)('classifies widening and narrowing transitions for enum/number and union', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    Account: {
+                        type: 'object',
+                        properties: {
+                            tier: { enum: ['basic', 'pro'] },
+                            score: { type: 'integer' },
+                            state: { oneOf: [{ type: 'string' }, { type: 'number' }] },
+                        },
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    Account: {
+                        type: 'object',
+                        properties: {
+                            tier: { enum: ['basic', 'pro', 'enterprise'] },
+                            score: { type: 'number' },
+                            state: { oneOf: [{ type: 'string' }] },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/tier') &&
+            change.severity === 'non-breaking'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/score') &&
+            change.severity === 'non-breaking'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/state') &&
+            change.severity === 'breaking'));
+    });
+    (0, node_test_1.test)('treats different refs and narrowing formats as breaking, widening formats as non-breaking', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            profile: { $ref: '#/components/schemas/ProfileV1' },
+                            count: { type: 'integer', format: 'int32' },
+                            ratio: { type: 'number', format: 'float' },
+                        },
+                    },
+                    ProfileV1: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                        },
+                    },
+                    ProfileV2: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            profile: { $ref: '#/components/schemas/ProfileV2' },
+                            count: { type: 'integer', format: 'int64' },
+                            ratio: { type: 'number', format: 'double' },
+                        },
+                    },
+                    ProfileV1: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                        },
+                    },
+                    ProfileV2: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const wideningReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(wideningReport.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/profile') &&
+            change.severity === 'breaking'));
+        node_assert_1.default.ok(wideningReport.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/count') &&
+            change.severity === 'non-breaking'));
+        node_assert_1.default.ok(wideningReport.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/ratio') &&
+            change.severity === 'non-breaking'));
+        const narrowingReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            count: { type: 'integer', format: 'int64' },
+                        },
+                    },
+                },
+            },
+        }, {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            count: { type: 'integer', format: 'int32' },
+                        },
+                    },
+                },
+            },
+        });
+        node_assert_1.default.ok(narrowingReport.changes.some(change => change.type === 'model.property.type.changed' &&
+            change.path.includes('/count') &&
+            change.severity === 'breaking'));
+    });
+    (0, node_test_1.test)('detects success response payload schema changes', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/users/{id}': {
+                    get: {
+                        responses: {
+                            '200': {
+                                description: 'ok',
+                                content: {
+                                    'application/json': {
+                                        schema: { type: 'integer' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/users/{id}': {
+                    get: {
+                        responses: {
+                            '200': {
+                                description: 'ok',
+                                content: {
+                                    'application/json': {
+                                        schema: { type: 'number' },
+                                    },
+                                },
+                            },
+                            '201': {
+                                description: 'created',
+                                content: {
+                                    'application/json': {
+                                        schema: { type: 'string' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'operation.response.success.type.changed' && change.severity === 'non-breaking'));
+        node_assert_1.default.ok(report.changes.some(change => change.type === 'operation.response.success.added'));
+    });
+    (0, node_test_1.test)('returns stable and deduplicated changes ordering', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/z': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    Zeta: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'string' },
+                        },
+                    },
+                    Alpha: {
+                        type: 'object',
+                        properties: {
+                            value: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        const keys = report.changes.map(change => `${change.path}|${change.type}|${change.severity}|${change.message}`);
+        const sortedKeys = [...keys].sort((left, right) => left.localeCompare(right));
+        const uniqueSize = new Set(keys).size;
+        node_assert_1.default.deepStrictEqual(keys, sortedKeys);
+        node_assert_1.default.equal(keys.length, uniqueSize);
+    });
+    (0, node_test_1.test)('builds semver recommendation matrix (major/minor/patch)', () => {
+        const majorReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        }, {
+            openapi: '3.0.0',
+            paths: {},
+            components: { schemas: {} },
+        });
+        node_assert_1.default.strictEqual(majorReport.recommendation.semver, 'major');
+        node_assert_1.default.ok(majorReport.recommendation.reasons.includes('HAS_BREAKING_CHANGES'));
+        const minorReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {},
+            components: { schemas: {} },
+        }, {
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        });
+        node_assert_1.default.strictEqual(minorReport.recommendation.semver, 'minor');
+        node_assert_1.default.ok(minorReport.recommendation.reasons.includes('HAS_BACKWARD_COMPATIBLE_CHANGES'));
+        const patchReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        }, {
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        });
+        node_assert_1.default.strictEqual(patchReport.recommendation.semver, 'patch');
+        node_assert_1.default.ok(patchReport.recommendation.reasons.includes('NO_API_SURFACE_CHANGES'));
+    });
+    (0, node_test_1.test)('builds governance violations and supports allowBreaking override', () => {
+        const oldSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        operationId: 'getUsers',
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        };
+        const newSpec = {
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            default: { description: 'fallback' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        };
+        const strictGovernanceReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec);
+        node_assert_1.default.ok(strictGovernanceReport.governance.violations.some(violation => violation.ruleId === 'NO_BREAKING_WITHOUT_FLAG'));
+        node_assert_1.default.ok(strictGovernanceReport.governance.violations.some(violation => violation.ruleId === 'REQUIRE_OPERATION_ID'));
+        node_assert_1.default.ok(strictGovernanceReport.governance.violations.some(violation => violation.ruleId === 'NO_DEFAULT_WITHOUT_2XX'));
+        node_assert_1.default.ok(strictGovernanceReport.governance.summary.errors > 0);
+        const allowedBreakingReport = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)(oldSpec, newSpec, { allowBreaking: true });
+        node_assert_1.default.ok(!allowedBreakingReport.governance.violations.some(violation => violation.ruleId === 'NO_BREAKING_WITHOUT_FLAG'));
+    });
+    (0, node_test_1.test)('applies governance config overrides in semantic diff report', () => {
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        operationId: 'getUsers',
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        }, {
+            openapi: '3.0.0',
+            paths: {
+                '/users': {
+                    get: {
+                        responses: {
+                            default: { description: 'fallback' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        }, {
+            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/semanticDiff/__tests__/semanticDiffReportSchema.test.d.ts

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

package/dist/core/semanticDiff/__tests__/semanticDiffReportSchema.test.d.ts.map

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

package/dist/core/semanticDiff/__tests__/semanticDiffReportSchema.test.js

@@ -0,0 +1,66 @@
+"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 analyzeOpenApiDiff_1 = require("../analyzeOpenApiDiff");
+const semanticDiffReportSchema_1 = require("../semanticDiffReportSchema");
+(0, node_test_1.describe)('@unit: semanticDiffReportSchema', () => {
+    (0, node_test_1.test)('validates report produced by analyzeOpenApiDiff', () => {
+        const report = (0, analyzeOpenApiDiff_1.analyzeOpenApiDiff)({
+            openapi: '3.0.0',
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        }, {
+            openapi: '3.0.0',
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                            '201': { description: 'created' },
+                        },
+                    },
+                },
+            },
+            components: { schemas: {} },
+        });
+        const validation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(report);
+        node_assert_1.default.strictEqual(validation.valid, true, validation.errors.join('\n'));
+    });
+    (0, node_test_1.test)('rejects report without schemaVersion', () => {
+        const malformedReport = {
+            summary: {
+                breaking: 0,
+                nonBreaking: 0,
+                informational: 0,
+            },
+            recommendation: {
+                semver: 'patch',
+                reason: 'No changes',
+            },
+            governance: {
+                summary: {
+                    errors: 0,
+                    warnings: 0,
+                    info: 0,
+                },
+                violations: [],
+            },
+            changes: [],
+        };
+        const validation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(malformedReport);
+        node_assert_1.default.strictEqual(validation.valid, false);
+        node_assert_1.default.ok(validation.errors.some(error => error.includes('schemaVersion')));
+    });
+});

package/dist/core/semanticDiff/analyzeOpenApiDiff.d.ts

@@ -0,0 +1,45 @@
+import { GovernancePolicyConfig, GovernanceReport } from '../governance/evaluateGovernanceRules';
+import { CommonOpenApi } from '../types/shared/CommonOpenApi.model';
+type ChangeSeverity = 'breaking' | 'non-breaking' | 'informational';
+type SemanticDiffSummary = {
+    breaking: number;
+    nonBreaking: number;
+    informational: number;
+};
+type SemanticDiffSemverRecommendation = 'major' | 'minor' | 'patch';
+type SemanticDiffConfidence = 'high' | 'medium' | 'low';
+type SemanticDiffRecommendationReason = 'HAS_BREAKING_CHANGES' | 'HAS_BACKWARD_COMPATIBLE_CHANGES' | 'HAS_INFORMATIONAL_ONLY_CHANGES' | 'NO_API_SURFACE_CHANGES';
+type SemanticDiffRecommendation = {
+    semver: SemanticDiffSemverRecommendation;
+    confidence: SemanticDiffConfidence;
+    reason: string;
+    reasons: SemanticDiffRecommendationReason[];
+};
+type SemanticDiffChange = {
+    type: string;
+    severity: ChangeSeverity;
+    message: string;
+    path: string;
+};
+export declare const SEMANTIC_DIFF_REPORT_SCHEMA_VERSION = "1.1.0";
+export type SemanticDiffReport = {
+    schemaVersion: string;
+    summary: SemanticDiffSummary;
+    recommendation: SemanticDiffRecommendation;
+    governance: GovernanceReport;
+    changes: SemanticDiffChange[];
+};
+type AnalyzeOpenApiDiffOptions = {
+    allowBreaking?: boolean;
+    governanceConfig?: GovernancePolicyConfig;
+};
+/**
+ * Creates semantic diff report between two OpenAPI specs.
+ */
+export declare function analyzeOpenApiDiff(oldSpec: CommonOpenApi, newSpec: CommonOpenApi, options?: AnalyzeOpenApiDiffOptions): SemanticDiffReport;
+/**
+ * Writes semantic diff report to JSON file and returns absolute path.
+ */
+export declare function writeSemanticDiffReport(report: SemanticDiffReport, reportFilePath: string): Promise<string>;
+export {};
+//# sourceMappingURL=analyzeOpenApiDiff.d.ts.map

package/dist/core/semanticDiff/analyzeOpenApiDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeOpenApiDiff.d.ts","sourceRoot":"","sources":["../../../src/core/semanticDiff/analyzeOpenApiDiff.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAA2B,MAAM,uCAAuC,CAAC;AAC1H,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,KAAK,cAAc,GAAG,UAAU,GAAG,cAAc,GAAG,eAAe,CAAC;AAEpE,KAAK,mBAAmB,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,KAAK,gCAAgC,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AACpE,KAAK,sBAAsB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AACxD,KAAK,gCAAgC,GAC/B,sBAAsB,GACtB,iCAAiC,GACjC,gCAAgC,GAChC,wBAAwB,CAAC;AAE/B,KAAK,0BAA0B,GAAG;IAC9B,MAAM,EAAE,gCAAgC,CAAC;IACzC,UAAU,EAAE,sBAAsB,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gCAAgC,EAAE,CAAC;CAC/C,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,mCAAmC,UAAU,CAAC;AAE3D,MAAM,MAAM,kBAAkB,GAAG;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,cAAc,EAAE,0BAA0B,CAAC;IAC3C,UAAU,EAAE,gBAAgB,CAAC;IAC7B,OAAO,EAAE,kBAAkB,EAAE,CAAC;CACjC,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AA6yBF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,GAAE,yBAA8B,GAAG,kBAAkB,CA2B9I;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAajH"}