@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/core-azure/lib/version-manager/api-version-manager.spec.js

@@ -0,0 +1,510 @@
+"use strict";
+/**
+ * Comprehensive tests for ApiVersionManager - Version management framework
+ *
+ * This test suite validates all functionality of the ApiVersionManager singleton,
+ * including version registration, resolution, migration analysis, and lifecycle management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_version_manager_1 = require("./api-version-manager");
+const version_interfaces_1 = require("./interfaces/version-interfaces");
+describe("ApiVersionManager", () => {
+    let manager;
+    // Test data setup
+    const TEST_RESOURCE_TYPE = "Microsoft.Test/resources";
+    const TEST_RESOURCE_TYPE_2 = "Microsoft.Test/resources2";
+    const createTestSchema = (version, properties = {}) => ({
+        resourceType: TEST_RESOURCE_TYPE,
+        version,
+        properties: {
+            name: {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+                description: "Resource name",
+                validation: [
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                        message: "Name is required",
+                    },
+                ],
+            },
+            location: {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+                description: "Resource location",
+            },
+            ...properties,
+        },
+        required: ["name", "location"],
+        optional: ["tags"],
+        deprecated: [],
+        transformationRules: {},
+        validationRules: [],
+    });
+    const createTestVersionConfig = (version, supportLevel = version_interfaces_1.VersionSupportLevel.ACTIVE) => ({
+        version,
+        schema: createTestSchema(version),
+        supportLevel,
+        releaseDate: version,
+        deprecationDate: undefined,
+        sunsetDate: undefined,
+        breakingChanges: [],
+        migrationGuide: `/docs/migration-${version}`,
+        changeLog: [
+            {
+                changeType: "added",
+                description: `Initial release of version ${version}`,
+                breaking: false,
+            },
+        ],
+    });
+    beforeEach(() => {
+        // Get a fresh instance for each test
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Clear any existing registrations by creating a new instance
+        // Note: In a real scenario, we'd want a way to reset the singleton for testing
+        // For now, we'll work with the singleton nature
+    });
+    describe("Singleton Pattern", () => {
+        it("should return the same instance on multiple calls", () => {
+            const instance1 = api_version_manager_1.ApiVersionManager.instance();
+            const instance2 = api_version_manager_1.ApiVersionManager.instance();
+            expect(instance1).toBe(instance2);
+            expect(instance1).toBeInstanceOf(api_version_manager_1.ApiVersionManager);
+        });
+        it("should be JSII compliant", () => {
+            // Test that the singleton pattern works as expected for JSII
+            expect(typeof api_version_manager_1.ApiVersionManager.instance).toBe("function");
+            expect(manager).toBeInstanceOf(api_version_manager_1.ApiVersionManager);
+        });
+    });
+    describe("Resource Type Registration", () => {
+        it("should register a resource type with versions successfully", () => {
+            const versions = [
+                createTestVersionConfig("2024-01-01"),
+                createTestVersionConfig("2024-06-01"),
+            ];
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            }).not.toThrow();
+            expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE);
+        });
+        it("should validate resource type input", () => {
+            expect(() => {
+                manager.registerResourceType("", []);
+            }).toThrow("Resource type cannot be empty");
+            expect(() => {
+                manager.registerResourceType("   ", []);
+            }).toThrow("Resource type cannot be empty");
+            expect(() => {
+                manager.registerResourceType("valid-type", []);
+            }).toThrow("Versions array cannot be empty");
+        });
+        it("should validate version configurations", () => {
+            const invalidVersionConfig = {
+                version: "",
+                schema: createTestSchema("2024-01-01"),
+                supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+                releaseDate: "2024-01-01",
+            };
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [
+                    invalidVersionConfig,
+                ]);
+            }).toThrow("Version string cannot be empty");
+        });
+        it("should detect duplicate versions", () => {
+            const versions = [
+                createTestVersionConfig("2024-01-01"),
+                createTestVersionConfig("2024-01-01"), // Duplicate
+            ];
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            }).toThrow("Duplicate version '2024-01-01' found");
+        });
+        it("should validate schema consistency", () => {
+            const invalidSchema = {
+                ...createTestSchema("2024-01-01"),
+                resourceType: "Different.Type/resource", // Wrong resource type
+            };
+            const versionConfig = {
+                ...createTestVersionConfig("2024-01-01"),
+                schema: invalidSchema,
+            };
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);
+            }).toThrow("Schema resource type 'Different.Type/resource' does not match registered resource type");
+        });
+        it("should validate schema version consistency", () => {
+            const invalidSchema = createTestSchema("2024-06-01"); // Different version
+            const versionConfig = {
+                ...createTestVersionConfig("2024-01-01"),
+                schema: invalidSchema,
+            };
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);
+            }).toThrow("Schema version '2024-06-01' does not match config version '2024-01-01'");
+        });
+        it("should validate release date format", () => {
+            const versionConfig = {
+                ...createTestVersionConfig("2024-01-01"),
+                releaseDate: "invalid-date",
+            };
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);
+            }).toThrow("Invalid release date format 'invalid-date'");
+        });
+    });
+    describe("Version Resolution", () => {
+        beforeEach(() => {
+            const versions = [
+                createTestVersionConfig("2024-01-01", version_interfaces_1.VersionSupportLevel.DEPRECATED),
+                createTestVersionConfig("2024-06-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+                createTestVersionConfig("2024-12-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+            ];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+        });
+        it("should return the latest active version", () => {
+            const latest = manager.latestVersion(TEST_RESOURCE_TYPE);
+            expect(latest).toBe("2024-12-01");
+        });
+        it("should return undefined for unregistered resource type", () => {
+            const latest = manager.latestVersion("Unregistered.Type/resource");
+            expect(latest).toBeUndefined();
+        });
+        it("should return all supported versions sorted by date", () => {
+            const versions = manager.supportedVersions(TEST_RESOURCE_TYPE);
+            expect(versions).toEqual(["2024-12-01", "2024-06-01", "2024-01-01"]);
+        });
+        it("should return empty array for unregistered resource type", () => {
+            const versions = manager.supportedVersions("Unregistered.Type/resource");
+            expect(versions).toEqual([]);
+        });
+        it("should validate version support correctly", () => {
+            expect(manager.validateVersionSupport(TEST_RESOURCE_TYPE, "2024-06-01")).toBe(true);
+            expect(manager.validateVersionSupport(TEST_RESOURCE_TYPE, "2024-01-01")).toBe(true);
+            expect(manager.validateVersionSupport(TEST_RESOURCE_TYPE, "2025-01-01")).toBe(false);
+            expect(manager.validateVersionSupport("Unregistered.Type/resource", "2024-01-01")).toBe(false);
+        });
+    });
+    describe("Version Configuration Retrieval", () => {
+        beforeEach(() => {
+            const versions = [
+                createTestVersionConfig("2024-01-01"),
+                createTestVersionConfig("2024-06-01"),
+            ];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+        });
+        it("should return version configuration for existing version", () => {
+            const config = manager.versionConfig(TEST_RESOURCE_TYPE, "2024-01-01");
+            expect(config).toBeDefined();
+            expect(config.version).toBe("2024-01-01");
+            expect(config.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+            expect(config.schema.resourceType).toBe(TEST_RESOURCE_TYPE);
+        });
+        it("should return undefined for non-existent version", () => {
+            const config = manager.versionConfig(TEST_RESOURCE_TYPE, "2025-01-01");
+            expect(config).toBeUndefined();
+        });
+        it("should return undefined for unregistered resource type", () => {
+            const config = manager.versionConfig("Unregistered.Type/resource", "2024-01-01");
+            expect(config).toBeUndefined();
+        });
+    });
+    describe("Migration Analysis", () => {
+        beforeEach(() => {
+            // Create versions with breaking changes
+            const version1 = createTestVersionConfig("2024-01-01");
+            const version2 = {
+                ...createTestVersionConfig("2024-06-01"),
+                breakingChanges: [
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.PROPERTY_REMOVED,
+                        property: "oldProperty",
+                        description: "Property oldProperty was removed",
+                        migrationPath: "Use newProperty instead",
+                    },
+                ],
+            };
+            const version3 = {
+                ...createTestVersionConfig("2024-12-01"),
+                breakingChanges: [
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.PROPERTY_TYPE_CHANGED,
+                        property: "name",
+                        oldValue: "string",
+                        newValue: "object",
+                        description: "Property name type changed from string to object",
+                        migrationPath: "Update name property to use object format",
+                    },
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.SCHEMA_RESTRUCTURED,
+                        description: "Schema was completely restructured",
+                        migrationPath: "Follow migration guide for complete schema changes",
+                    },
+                ],
+            };
+            manager.registerResourceType(TEST_RESOURCE_TYPE, [
+                version1,
+                version2,
+                version3,
+            ]);
+        });
+        it("should analyze migration between compatible versions", () => {
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-01-01");
+            expect(analysis.fromVersion).toBe("2024-01-01");
+            expect(analysis.toVersion).toBe("2024-01-01");
+            expect(analysis.compatible).toBe(true);
+            expect(analysis.breakingChanges).toHaveLength(0);
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.LOW);
+            expect(analysis.automaticUpgradePossible).toBe(true);
+        });
+        it("should analyze migration with breaking changes", () => {
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-06-01");
+            expect(analysis.fromVersion).toBe("2024-01-01");
+            expect(analysis.toVersion).toBe("2024-06-01");
+            expect(analysis.compatible).toBe(false);
+            expect(analysis.breakingChanges).toHaveLength(1);
+            expect(analysis.breakingChanges[0].changeType).toBe(version_interfaces_1.BreakingChangeType.PROPERTY_REMOVED);
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.LOW);
+            expect(analysis.automaticUpgradePossible).toBe(false);
+        });
+        it("should analyze migration with multiple breaking changes", () => {
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-12-01");
+            expect(analysis.fromVersion).toBe("2024-01-01");
+            expect(analysis.toVersion).toBe("2024-12-01");
+            expect(analysis.compatible).toBe(false);
+            expect(analysis.breakingChanges).toHaveLength(3); // All breaking changes from versions 2 and 3
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.BREAKING);
+            expect(analysis.automaticUpgradePossible).toBe(false);
+        });
+        it("should throw error for invalid version migration analysis", () => {
+            expect(() => {
+                manager.analyzeMigration(TEST_RESOURCE_TYPE, "invalid-version", "2024-01-01");
+            }).toThrow("Source version 'invalid-version' not found");
+            expect(() => {
+                manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "invalid-version");
+            }).toThrow("Target version 'invalid-version' not found");
+            expect(() => {
+                manager.analyzeMigration("Unregistered.Type/resource", "2024-01-01", "2024-06-01");
+            }).toThrow("Source version '2024-01-01' not found for resource type 'Unregistered.Type/resource'");
+        });
+    });
+    describe("Version Lifecycle Management", () => {
+        beforeEach(() => {
+            const deprecatedVersion = {
+                ...createTestVersionConfig("2024-01-01", version_interfaces_1.VersionSupportLevel.DEPRECATED),
+                sunsetDate: "2025-01-01",
+            };
+            const activeVersion = createTestVersionConfig("2024-06-01", version_interfaces_1.VersionSupportLevel.ACTIVE);
+            manager.registerResourceType(TEST_RESOURCE_TYPE, [
+                deprecatedVersion,
+                activeVersion,
+            ]);
+        });
+        it("should return version lifecycle information", () => {
+            const lifecycle = manager.versionLifecycle(TEST_RESOURCE_TYPE, "2024-01-01");
+            expect(lifecycle).toBeDefined();
+            expect(lifecycle.version).toBe("2024-01-01");
+            expect(lifecycle.phase).toBe(version_interfaces_1.VersionSupportLevel.DEPRECATED);
+            expect(lifecycle.transitionDate).toBe("2024-01-01");
+            expect(lifecycle.nextPhase).toBe(version_interfaces_1.VersionSupportLevel.SUNSET);
+            expect(lifecycle.estimatedSunsetDate).toBe("2025-01-01");
+        });
+        it("should return undefined for non-existent version lifecycle", () => {
+            const lifecycle = manager.versionLifecycle(TEST_RESOURCE_TYPE, "invalid-version");
+            expect(lifecycle).toBeUndefined();
+        });
+        it("should generate migration warnings for deprecated versions", () => {
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-06-01");
+            expect(analysis.warnings).toContain("Source version '2024-01-01' is deprecated. Consider migrating to avoid future compatibility issues.");
+        });
+    });
+    describe("Version Constraints and Selection", () => {
+        beforeEach(() => {
+            const versions = [
+                createTestVersionConfig("2023-01-01", version_interfaces_1.VersionSupportLevel.DEPRECATED),
+                createTestVersionConfig("2024-01-01", version_interfaces_1.VersionSupportLevel.MAINTENANCE),
+                createTestVersionConfig("2024-06-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+                createTestVersionConfig("2024-12-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+            ];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+        });
+        it("should find version by support level constraint", () => {
+            const constraints = {
+                supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+            };
+            const version = manager._findVersionByConstraints(TEST_RESOURCE_TYPE, constraints);
+            expect(version).toBe("2024-12-01"); // Latest active version
+        });
+        it("should find version excluding deprecated", () => {
+            const constraints = {
+                excludeDeprecated: true,
+            };
+            const version = manager._findVersionByConstraints(TEST_RESOURCE_TYPE, constraints);
+            expect(version).toBe("2024-12-01"); // Latest non-deprecated version
+        });
+        it("should find version with date constraint", () => {
+            const constraints = {
+                notOlderThan: new Date("2024-06-01"),
+            };
+            const version = manager._findVersionByConstraints(TEST_RESOURCE_TYPE, constraints);
+            expect(version).toBe("2024-12-01"); // Latest version after date
+        });
+        it("should return undefined when no version matches constraints", () => {
+            const constraints = {
+                supportLevel: "non-existent-level",
+            };
+            const version = manager._findVersionByConstraints(TEST_RESOURCE_TYPE, constraints);
+            expect(version).toBeUndefined();
+        });
+        it("should return undefined for unregistered resource type", () => {
+            const constraints = {
+                supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+            };
+            const version = manager._findVersionByConstraints("Unregistered.Type/resource", constraints);
+            expect(version).toBeUndefined();
+        });
+    });
+    describe("Migration Effort Calculation", () => {
+        it("should calculate low effort for no breaking changes", () => {
+            const versions = [
+                createTestVersionConfig("2024-01-01"),
+                createTestVersionConfig("2024-06-01"),
+            ];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-06-01");
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.LOW);
+        });
+        it("should calculate medium effort for few breaking changes", () => {
+            const version1 = createTestVersionConfig("2024-01-01");
+            const version2 = {
+                ...createTestVersionConfig("2024-06-01"),
+                breakingChanges: [
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.PROPERTY_RENAMED,
+                        property: "oldName",
+                        newValue: "newName",
+                        description: "Property renamed",
+                    },
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.PROPERTY_RENAMED,
+                        property: "oldName2",
+                        newValue: "newName2",
+                        description: "Another property renamed",
+                    },
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.PROPERTY_RENAMED,
+                        property: "oldName3",
+                        newValue: "newName3",
+                        description: "Third property renamed",
+                    },
+                ],
+            };
+            manager.registerResourceType(TEST_RESOURCE_TYPE, [version1, version2]);
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-06-01");
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.MEDIUM);
+        });
+        it("should calculate breaking effort for schema restructure", () => {
+            const version1 = createTestVersionConfig("2024-01-01");
+            const version2 = {
+                ...createTestVersionConfig("2024-06-01"),
+                breakingChanges: [
+                    {
+                        changeType: version_interfaces_1.BreakingChangeType.SCHEMA_RESTRUCTURED,
+                        description: "Complete schema restructure",
+                    },
+                ],
+            };
+            manager.registerResourceType(TEST_RESOURCE_TYPE, [version1, version2]);
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-06-01");
+            expect(analysis.estimatedEffort).toBe(version_interfaces_1.MigrationEffort.BREAKING);
+        });
+    });
+    describe("Multiple Resource Types", () => {
+        it("should handle multiple resource types independently", () => {
+            const versions1 = [createTestVersionConfig("2024-01-01")];
+            const versions2 = [
+                {
+                    ...createTestVersionConfig("2024-06-01"),
+                    schema: {
+                        ...createTestSchema("2024-06-01"),
+                        resourceType: TEST_RESOURCE_TYPE_2,
+                    },
+                },
+            ];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions1);
+            manager.registerResourceType(TEST_RESOURCE_TYPE_2, versions2);
+            expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE);
+            expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE_2);
+            expect(manager.latestVersion(TEST_RESOURCE_TYPE)).toBe("2024-01-01");
+            expect(manager.latestVersion(TEST_RESOURCE_TYPE_2)).toBe("2024-06-01");
+        });
+        it("should return all registered resource types", () => {
+            const versions = [createTestVersionConfig("2024-01-01")];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            const resourceTypes = manager.registeredResourceTypes();
+            expect(Array.isArray(resourceTypes)).toBe(true);
+            expect(resourceTypes.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Error Handling and Edge Cases", () => {
+        it("should handle empty version arrays gracefully", () => {
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, []);
+            }).toThrow("Versions array cannot be empty");
+        });
+        it("should handle null/undefined version configurations", () => {
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [null]);
+            }).toThrow();
+        });
+        it("should handle invalid schema objects", () => {
+            const invalidVersionConfig = {
+                version: "2024-01-01",
+                schema: null,
+                supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+                releaseDate: "2024-01-01",
+            };
+            expect(() => {
+                manager.registerResourceType(TEST_RESOURCE_TYPE, [
+                    invalidVersionConfig,
+                ]);
+            }).toThrow("Schema is required");
+        });
+        it("should handle migration analysis with same from/to versions", () => {
+            const versions = [createTestVersionConfig("2024-01-01")];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            const analysis = manager.analyzeMigration(TEST_RESOURCE_TYPE, "2024-01-01", "2024-01-01");
+            expect(analysis.compatible).toBe(true);
+            expect(analysis.breakingChanges).toHaveLength(0);
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant method signatures", () => {
+            // Test that all public methods are accessible and have expected signatures
+            expect(typeof manager.registerResourceType).toBe("function");
+            expect(typeof manager.latestVersion).toBe("function");
+            expect(typeof manager.versionConfig).toBe("function");
+            expect(typeof manager.supportedVersions).toBe("function");
+            expect(typeof manager.analyzeMigration).toBe("function");
+            expect(typeof manager.validateVersionSupport).toBe("function");
+            expect(typeof manager.registeredResourceTypes).toBe("function");
+            expect(typeof manager.versionLifecycle).toBe("function");
+        });
+        it("should return JSII-compliant types", () => {
+            const versions = [createTestVersionConfig("2024-01-01")];
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+            // Test return types
+            const latest = manager.latestVersion(TEST_RESOURCE_TYPE);
+            expect(typeof latest === "string" || latest === undefined).toBe(true);
+            const supportedVersions = manager.supportedVersions(TEST_RESOURCE_TYPE);
+            expect(Array.isArray(supportedVersions)).toBe(true);
+            const isSupported = manager.validateVersionSupport(TEST_RESOURCE_TYPE, "2024-01-01");
+            expect(typeof isSupported).toBe("boolean");
+            const resourceTypes = manager.registeredResourceTypes();
+            expect(Array.isArray(resourceTypes)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-version-manager.spec.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/version-manager/api-version-manager.spec.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAEH,+DAA0D;AAC1D,wEAUyC;AAEzC,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IACjC,IAAI,OAA0B,CAAC;IAE/B,kBAAkB;IAClB,MAAM,kBAAkB,GAAG,0BAA0B,CAAC;IACtD,MAAM,oBAAoB,GAAG,2BAA2B,CAAC;IAEzD,MAAM,gBAAgB,GAAG,CACvB,OAAe,EACf,aAAoD,EAAE,EAC3C,EAAE,CAAC,CAAC;QACf,YAAY,EAAE,kBAAkB;QAChC,OAAO;QACP,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,QAAQ,EAAE,iCAAY,CAAC,MAAM;gBAC7B,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,eAAe;gBAC5B,UAAU,EAAE;oBACV;wBACE,QAAQ,EAAE,uCAAkB,CAAC,QAAQ;wBACrC,OAAO,EAAE,kBAAkB;qBAC5B;iBACF;aACF;YACD,QAAQ,EAAE;gBACR,QAAQ,EAAE,iCAAY,CAAC,MAAM;gBAC7B,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,mBAAmB;aACjC;YACD,GAAG,UAAU;SACd;QACD,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC;QAC9B,QAAQ,EAAE,CAAC,MAAM,CAAC;QAClB,UAAU,EAAE,EAAE;QACd,mBAAmB,EAAE,EAAE;QACvB,eAAe,EAAE,EAAE;KACpB,CAAC,CAAC;IAEH,MAAM,uBAAuB,GAAG,CAC9B,OAAe,EACf,eAAuB,wCAAmB,CAAC,MAAM,EAClC,EAAE,CAAC,CAAC;QACnB,OAAO;QACP,MAAM,EAAE,gBAAgB,CAAC,OAAO,CAAC;QACjC,YAAY;QACZ,WAAW,EAAE,OAAO;QACpB,eAAe,EAAE,SAAS;QAC1B,UAAU,EAAE,SAAS;QACrB,eAAe,EAAE,EAAE;QACnB,cAAc,EAAE,mBAAmB,OAAO,EAAE;QAC5C,SAAS,EAAE;YACT;gBACE,UAAU,EAAE,OAAO;gBACnB,WAAW,EAAE,8BAA8B,OAAO,EAAE;gBACpD,QAAQ,EAAE,KAAK;aAChB;SACF;KACF,CAAC,CAAC;IAEH,UAAU,CAAC,GAAG,EAAE;QACd,qCAAqC;QACrC,OAAO,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;QAEvC,8DAA8D;QAC9D,+EAA+E;QAC/E,gDAAgD;IAClD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;QACjC,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;YAC3D,MAAM,SAAS,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;YAC/C,MAAM,SAAS,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;YAE/C,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAClC,MAAM,CAAC,SAAS,CAAC,CAAC,cAAc,CAAC,uCAAiB,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;YAClC,6DAA6D;YAC7D,MAAM,CAAC,OAAO,uCAAiB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC3D,MAAM,CAAC,OAAO,CAAC,CAAC,cAAc,CAAC,uCAAiB,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;QAC1C,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,CAAC;gBACrC,uBAAuB,CAAC,YAAY,CAAC;aACtC,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAC7D,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YAEjB,MAAM,CAAC,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;YAC7C,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACvC,CAAC,CAAC,CAAC,OAAO,CAAC,+BAA+B,CAAC,CAAC;YAE5C,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC1C,CAAC,CAAC,CAAC,OAAO,CAAC,+BAA+B,CAAC,CAAC;YAE5C,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAChD,MAAM,oBAAoB,GAAG;gBAC3B,OAAO,EAAE,EAAE;gBACX,MAAM,EAAE,gBAAgB,CAAC,YAAY,CAAC;gBACtC,YAAY,EAAE,wCAAmB,CAAC,MAAM;gBACxC,WAAW,EAAE,YAAY;aACT,CAAC;YAEnB,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE;oBAC/C,oBAAoB;iBACrB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,CAAC;gBACrC,uBAAuB,CAAC,YAAY,CAAC,EAAE,YAAY;aACpD,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAC7D,CAAC,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,MAAM,aAAa,GAAG;gBACpB,GAAG,gBAAgB,CAAC,YAAY,CAAC;gBACjC,YAAY,EAAE,yBAAyB,EAAE,sBAAsB;aAChE,CAAC;YAEF,MAAM,aAAa,GAAG;gBACpB,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,MAAM,EAAE,aAAa;aACtB,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC,OAAO,CACR,wFAAwF,CACzF,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,aAAa,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC,oBAAoB;YAC1E,MAAM,aAAa,GAAG;gBACpB,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,MAAM,EAAE,aAAa;aACtB,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC,OAAO,CACR,wEAAwE,CACzE,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;YAC7C,MAAM,aAAa,GAAG;gBACpB,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,WAAW,EAAE,cAAc;aAC5B,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC,OAAO,CAAC,4CAA4C,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;QAClC,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,UAAU,CAAC;gBACrE,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,MAAM,CAAC;gBACjE,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,MAAM,CAAC;aAClE,CAAC;YACF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;YACzD,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,4BAA4B,CAAC,CAAC;YACnE,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;YAC/D,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;YAClE,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,4BAA4B,CAAC,CAAC;YACzE,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;YACnD,MAAM,CACJ,OAAO,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CACjE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACb,MAAM,CACJ,OAAO,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CACjE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACb,MAAM,CACJ,OAAO,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,YAAY,CAAC,CACjE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACd,MAAM,CACJ,OAAO,CAAC,sBAAsB,CAC5B,4BAA4B,EAC5B,YAAY,CACb,CACF,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC/C,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,CAAC;gBACrC,uBAAuB,CAAC,YAAY,CAAC;aACtC,CAAC;YACF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;YAClE,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;YAEvE,MAAM,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;YAC7B,MAAM,CAAC,MAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC3C,MAAM,CAAC,MAAO,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,wCAAmB,CAAC,MAAM,CAAC,CAAC;YAC9D,MAAM,CAAC,MAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;YACvE,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAClC,4BAA4B,EAC5B,YAAY,CACb,CAAC;YACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;QAClC,UAAU,CAAC,GAAG,EAAE;YACd,wCAAwC;YACxC,MAAM,QAAQ,GAAG,uBAAuB,CAAC,YAAY,CAAC,CAAC;YACvD,MAAM,QAAQ,GAAG;gBACf,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,eAAe,EAAE;oBACf;wBACE,UAAU,EAAE,uCAAkB,CAAC,gBAAgB;wBAC/C,QAAQ,EAAE,aAAa;wBACvB,WAAW,EAAE,kCAAkC;wBAC/C,aAAa,EAAE,yBAAyB;qBACzC;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG;gBACf,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,eAAe,EAAE;oBACf;wBACE,UAAU,EAAE,uCAAkB,CAAC,qBAAqB;wBACpD,QAAQ,EAAE,MAAM;wBAChB,QAAQ,EAAE,QAAQ;wBAClB,QAAQ,EAAE,QAAQ;wBAClB,WAAW,EAAE,kDAAkD;wBAC/D,aAAa,EAAE,2CAA2C;qBAC3D;oBACD;wBACE,UAAU,EAAE,uCAAkB,CAAC,mBAAmB;wBAClD,WAAW,EAAE,oCAAoC;wBACjD,aAAa,EAAE,oDAAoD;qBACpE;iBACF;aACF,CAAC;YAEF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE;gBAC/C,QAAQ;gBACR,QAAQ;gBACR,QAAQ;aACT,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YAEF,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChD,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,GAAG,CAAC,CAAC;YAC3D,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gDAAgD,EAAE,GAAG,EAAE;YACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YAEF,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChD,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,CACjD,uCAAkB,CAAC,gBAAgB,CACpC,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,GAAG,CAAC,CAAC;YAC3D,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YAEF,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChD,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,6CAA6C;YAC/F,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,QAAQ,CAAC,CAAC;YAChE,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;YACnE,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,gBAAgB,CACtB,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,CACb,CAAC;YACJ,CAAC,CAAC,CAAC,OAAO,CAAC,4CAA4C,CAAC,CAAC;YAEzD,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,gBAAgB,CACtB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,CAClB,CAAC;YACJ,CAAC,CAAC,CAAC,OAAO,CAAC,4CAA4C,CAAC,CAAC;YAEzD,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,gBAAgB,CACtB,4BAA4B,EAC5B,YAAY,EACZ,YAAY,CACb,CAAC;YACJ,CAAC,CAAC,CAAC,OAAO,CACR,sFAAsF,CACvF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC5C,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,iBAAiB,GAAG;gBACxB,GAAG,uBAAuB,CACxB,YAAY,EACZ,wCAAmB,CAAC,UAAU,CAC/B;gBACD,UAAU,EAAE,YAAY;aACzB,CAAC;YAEF,MAAM,aAAa,GAAG,uBAAuB,CAC3C,YAAY,EACZ,wCAAmB,CAAC,MAAM,CAC3B,CAAC;YAEF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE;gBAC/C,iBAAiB;gBACjB,aAAa;aACd,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,SAAS,GAAG,OAAO,CAAC,gBAAgB,CACxC,kBAAkB,EAClB,YAAY,CACb,CAAC;YAEF,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YAChC,MAAM,CAAC,SAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,MAAM,CAAC,SAAU,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,wCAAmB,CAAC,UAAU,CAAC,CAAC;YAC9D,MAAM,CAAC,SAAU,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACrD,MAAM,CAAC,SAAU,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,wCAAmB,CAAC,MAAM,CAAC,CAAC;YAC9D,MAAM,CAAC,SAAU,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,SAAS,GAAG,OAAO,CAAC,gBAAgB,CACxC,kBAAkB,EAClB,iBAAiB,CAClB,CAAC;YACF,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YAEF,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,SAAS,CACjC,qGAAqG,CACtG,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,mCAAmC,EAAE,GAAG,EAAE;QACjD,UAAU,CAAC,GAAG,EAAE;YACd,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,UAAU,CAAC;gBACrE,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,WAAW,CAAC;gBACtE,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,MAAM,CAAC;gBACjE,uBAAuB,CAAC,YAAY,EAAE,wCAAmB,CAAC,MAAM,CAAC;aAClE,CAAC;YACF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,MAAM,WAAW,GAAuB;gBACtC,YAAY,EAAE,wCAAmB,CAAC,MAAM;aACzC,CAAC;YAEF,MAAM,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAC/C,kBAAkB,EAClB,WAAW,CACZ,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,wBAAwB;QAC9D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,WAAW,GAAuB;gBACtC,iBAAiB,EAAE,IAAI;aACxB,CAAC;YAEF,MAAM,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAC/C,kBAAkB,EAClB,WAAW,CACZ,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,gCAAgC;QACtE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,WAAW,GAAuB;gBACtC,YAAY,EAAE,IAAI,IAAI,CAAC,YAAY,CAAC;aACrC,CAAC;YAEF,MAAM,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAC/C,kBAAkB,EAClB,WAAW,CACZ,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,4BAA4B;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;YACrE,MAAM,WAAW,GAAuB;gBACtC,YAAY,EAAE,oBAAoB;aACnC,CAAC;YAEF,MAAM,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAC/C,kBAAkB,EAClB,WAAW,CACZ,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,MAAM,WAAW,GAAuB;gBACtC,YAAY,EAAE,wCAAmB,CAAC,MAAM;aACzC,CAAC;YAEF,MAAM,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAC/C,4BAA4B,EAC5B,WAAW,CACZ,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC5C,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,QAAQ,GAAG;gBACf,uBAAuB,CAAC,YAAY,CAAC;gBACrC,uBAAuB,CAAC,YAAY,CAAC;aACtC,CAAC;YACF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAE3D,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,GAAG,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,QAAQ,GAAG,uBAAuB,CAAC,YAAY,CAAC,CAAC;YACvD,MAAM,QAAQ,GAAG;gBACf,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,eAAe,EAAE;oBACf;wBACE,UAAU,EAAE,uCAAkB,CAAC,gBAAgB;wBAC/C,QAAQ,EAAE,SAAS;wBACnB,QAAQ,EAAE,SAAS;wBACnB,WAAW,EAAE,kBAAkB;qBAChC;oBACD;wBACE,UAAU,EAAE,uCAAkB,CAAC,gBAAgB;wBAC/C,QAAQ,EAAE,UAAU;wBACpB,QAAQ,EAAE,UAAU;wBACpB,WAAW,EAAE,0BAA0B;qBACxC;oBACD;wBACE,UAAU,EAAE,uCAAkB,CAAC,gBAAgB;wBAC/C,QAAQ,EAAE,UAAU;wBACpB,QAAQ,EAAE,UAAU;wBACpB,WAAW,EAAE,wBAAwB;qBACtC;iBACF;aACF,CAAC;YAEF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YAEvE,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,MAAM,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,QAAQ,GAAG,uBAAuB,CAAC,YAAY,CAAC,CAAC;YACvD,MAAM,QAAQ,GAAG;gBACf,GAAG,uBAAuB,CAAC,YAAY,CAAC;gBACxC,eAAe,EAAE;oBACf;wBACE,UAAU,EAAE,uCAAkB,CAAC,mBAAmB;wBAClD,WAAW,EAAE,6BAA6B;qBAC3C;iBACF;aACF,CAAC;YAEF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YAEvE,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,oCAAe,CAAC,QAAQ,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,SAAS,GAAG,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC,CAAC;YAC1D,MAAM,SAAS,GAAG;gBAChB;oBACE,GAAG,uBAAuB,CAAC,YAAY,CAAC;oBACxC,MAAM,EAAE;wBACN,GAAG,gBAAgB,CAAC,YAAY,CAAC;wBACjC,YAAY,EAAE,oBAAoB;qBACnC;iBACF;aACF,CAAC;YAEF,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,SAAS,CAAC,CAAC;YAC5D,OAAO,CAAC,oBAAoB,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;YAE9D,MAAM,CAAC,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;YACxE,MAAM,CAAC,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;YAE1E,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACrE,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,QAAQ,GAAG,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC,CAAC;YACzD,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAE3D,MAAM,aAAa,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;YACxD,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChD,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;YACvD,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,CAAC,IAAW,CAAC,CAAC,CAAC;YAClE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QACf,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,oBAAoB,GAAG;gBAC3B,OAAO,EAAE,YAAY;gBACrB,MAAM,EAAE,IAAW;gBACnB,YAAY,EAAE,wCAAmB,CAAC,MAAM;gBACxC,WAAW,EAAE,YAAY;aAC1B,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE;oBAC/C,oBAAoB;iBACrB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;YACrE,MAAM,QAAQ,GAAG,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC,CAAC;YACzD,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAE3D,MAAM,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CACvC,kBAAkB,EAClB,YAAY,EACZ,YAAY,CACb,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,2EAA2E;YAC3E,MAAM,CAAC,OAAO,OAAO,CAAC,oBAAoB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7D,MAAM,CAAC,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACtD,MAAM,CAAC,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACtD,MAAM,CAAC,OAAO,OAAO,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC1D,MAAM,CAAC,OAAO,OAAO,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACzD,MAAM,CAAC,OAAO,OAAO,CAAC,sBAAsB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/D,MAAM,CAAC,OAAO,OAAO,CAAC,uBAAuB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAChE,MAAM,CAAC,OAAO,OAAO,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,MAAM,QAAQ,GAAG,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC,CAAC;YACzD,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAE3D,oBAAoB;YACpB,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;YACzD,MAAM,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEtE,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;YACxE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEpD,MAAM,WAAW,GAAG,OAAO,CAAC,sBAAsB,CAChD,kBAAkB,EAClB,YAAY,CACb,CAAC;YACF,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAE3C,MAAM,aAAa,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;YACxD,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Comprehensive tests for ApiVersionManager - Version management framework\n *\n * This test suite validates all functionality of the ApiVersionManager singleton,\n * including version registration, resolution, migration analysis, and lifecycle management.\n */\n\nimport { ApiVersionManager } from \"./api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  VersionSupportLevel,\n  MigrationEffort,\n  BreakingChangeType,\n  VersionConstraints,\n} from \"./interfaces/version-interfaces\";\n\ndescribe(\"ApiVersionManager\", () => {\n  let manager: ApiVersionManager;\n\n  // Test data setup\n  const TEST_RESOURCE_TYPE = \"Microsoft.Test/resources\";\n  const TEST_RESOURCE_TYPE_2 = \"Microsoft.Test/resources2\";\n\n  const createTestSchema = (\n    version: string,\n    properties: { [key: string]: PropertyDefinition } = {},\n  ): ApiSchema => ({\n    resourceType: TEST_RESOURCE_TYPE,\n    version,\n    properties: {\n      name: {\n        dataType: PropertyType.STRING,\n        required: true,\n        description: \"Resource name\",\n        validation: [\n          {\n            ruleType: ValidationRuleType.REQUIRED,\n            message: \"Name is required\",\n          },\n        ],\n      },\n      location: {\n        dataType: PropertyType.STRING,\n        required: true,\n        description: \"Resource location\",\n      },\n      ...properties,\n    },\n    required: [\"name\", \"location\"],\n    optional: [\"tags\"],\n    deprecated: [],\n    transformationRules: {},\n    validationRules: [],\n  });\n\n  const createTestVersionConfig = (\n    version: string,\n    supportLevel: string = VersionSupportLevel.ACTIVE,\n  ): VersionConfig => ({\n    version,\n    schema: createTestSchema(version),\n    supportLevel,\n    releaseDate: version,\n    deprecationDate: undefined,\n    sunsetDate: undefined,\n    breakingChanges: [],\n    migrationGuide: `/docs/migration-${version}`,\n    changeLog: [\n      {\n        changeType: \"added\",\n        description: `Initial release of version ${version}`,\n        breaking: false,\n      },\n    ],\n  });\n\n  beforeEach(() => {\n    // Get a fresh instance for each test\n    manager = ApiVersionManager.instance();\n\n    // Clear any existing registrations by creating a new instance\n    // Note: In a real scenario, we'd want a way to reset the singleton for testing\n    // For now, we'll work with the singleton nature\n  });\n\n  describe(\"Singleton Pattern\", () => {\n    it(\"should return the same instance on multiple calls\", () => {\n      const instance1 = ApiVersionManager.instance();\n      const instance2 = ApiVersionManager.instance();\n\n      expect(instance1).toBe(instance2);\n      expect(instance1).toBeInstanceOf(ApiVersionManager);\n    });\n\n    it(\"should be JSII compliant\", () => {\n      // Test that the singleton pattern works as expected for JSII\n      expect(typeof ApiVersionManager.instance).toBe(\"function\");\n      expect(manager).toBeInstanceOf(ApiVersionManager);\n    });\n  });\n\n  describe(\"Resource Type Registration\", () => {\n    it(\"should register a resource type with versions successfully\", () => {\n      const versions = [\n        createTestVersionConfig(\"2024-01-01\"),\n        createTestVersionConfig(\"2024-06-01\"),\n      ];\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n      }).not.toThrow();\n\n      expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE);\n    });\n\n    it(\"should validate resource type input\", () => {\n      expect(() => {\n        manager.registerResourceType(\"\", []);\n      }).toThrow(\"Resource type cannot be empty\");\n\n      expect(() => {\n        manager.registerResourceType(\"   \", []);\n      }).toThrow(\"Resource type cannot be empty\");\n\n      expect(() => {\n        manager.registerResourceType(\"valid-type\", []);\n      }).toThrow(\"Versions array cannot be empty\");\n    });\n\n    it(\"should validate version configurations\", () => {\n      const invalidVersionConfig = {\n        version: \"\",\n        schema: createTestSchema(\"2024-01-01\"),\n        supportLevel: VersionSupportLevel.ACTIVE,\n        releaseDate: \"2024-01-01\",\n      } as VersionConfig;\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [\n          invalidVersionConfig,\n        ]);\n      }).toThrow(\"Version string cannot be empty\");\n    });\n\n    it(\"should detect duplicate versions\", () => {\n      const versions = [\n        createTestVersionConfig(\"2024-01-01\"),\n        createTestVersionConfig(\"2024-01-01\"), // Duplicate\n      ];\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n      }).toThrow(\"Duplicate version '2024-01-01' found\");\n    });\n\n    it(\"should validate schema consistency\", () => {\n      const invalidSchema = {\n        ...createTestSchema(\"2024-01-01\"),\n        resourceType: \"Different.Type/resource\", // Wrong resource type\n      };\n\n      const versionConfig = {\n        ...createTestVersionConfig(\"2024-01-01\"),\n        schema: invalidSchema,\n      };\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);\n      }).toThrow(\n        \"Schema resource type 'Different.Type/resource' does not match registered resource type\",\n      );\n    });\n\n    it(\"should validate schema version consistency\", () => {\n      const invalidSchema = createTestSchema(\"2024-06-01\"); // Different version\n      const versionConfig = {\n        ...createTestVersionConfig(\"2024-01-01\"),\n        schema: invalidSchema,\n      };\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);\n      }).toThrow(\n        \"Schema version '2024-06-01' does not match config version '2024-01-01'\",\n      );\n    });\n\n    it(\"should validate release date format\", () => {\n      const versionConfig = {\n        ...createTestVersionConfig(\"2024-01-01\"),\n        releaseDate: \"invalid-date\",\n      };\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [versionConfig]);\n      }).toThrow(\"Invalid release date format 'invalid-date'\");\n    });\n  });\n\n  describe(\"Version Resolution\", () => {\n    beforeEach(() => {\n      const versions = [\n        createTestVersionConfig(\"2024-01-01\", VersionSupportLevel.DEPRECATED),\n        createTestVersionConfig(\"2024-06-01\", VersionSupportLevel.ACTIVE),\n        createTestVersionConfig(\"2024-12-01\", VersionSupportLevel.ACTIVE),\n      ];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n    });\n\n    it(\"should return the latest active version\", () => {\n      const latest = manager.latestVersion(TEST_RESOURCE_TYPE);\n      expect(latest).toBe(\"2024-12-01\");\n    });\n\n    it(\"should return undefined for unregistered resource type\", () => {\n      const latest = manager.latestVersion(\"Unregistered.Type/resource\");\n      expect(latest).toBeUndefined();\n    });\n\n    it(\"should return all supported versions sorted by date\", () => {\n      const versions = manager.supportedVersions(TEST_RESOURCE_TYPE);\n      expect(versions).toEqual([\"2024-12-01\", \"2024-06-01\", \"2024-01-01\"]);\n    });\n\n    it(\"should return empty array for unregistered resource type\", () => {\n      const versions = manager.supportedVersions(\"Unregistered.Type/resource\");\n      expect(versions).toEqual([]);\n    });\n\n    it(\"should validate version support correctly\", () => {\n      expect(\n        manager.validateVersionSupport(TEST_RESOURCE_TYPE, \"2024-06-01\"),\n      ).toBe(true);\n      expect(\n        manager.validateVersionSupport(TEST_RESOURCE_TYPE, \"2024-01-01\"),\n      ).toBe(true);\n      expect(\n        manager.validateVersionSupport(TEST_RESOURCE_TYPE, \"2025-01-01\"),\n      ).toBe(false);\n      expect(\n        manager.validateVersionSupport(\n          \"Unregistered.Type/resource\",\n          \"2024-01-01\",\n        ),\n      ).toBe(false);\n    });\n  });\n\n  describe(\"Version Configuration Retrieval\", () => {\n    beforeEach(() => {\n      const versions = [\n        createTestVersionConfig(\"2024-01-01\"),\n        createTestVersionConfig(\"2024-06-01\"),\n      ];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n    });\n\n    it(\"should return version configuration for existing version\", () => {\n      const config = manager.versionConfig(TEST_RESOURCE_TYPE, \"2024-01-01\");\n\n      expect(config).toBeDefined();\n      expect(config!.version).toBe(\"2024-01-01\");\n      expect(config!.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n      expect(config!.schema.resourceType).toBe(TEST_RESOURCE_TYPE);\n    });\n\n    it(\"should return undefined for non-existent version\", () => {\n      const config = manager.versionConfig(TEST_RESOURCE_TYPE, \"2025-01-01\");\n      expect(config).toBeUndefined();\n    });\n\n    it(\"should return undefined for unregistered resource type\", () => {\n      const config = manager.versionConfig(\n        \"Unregistered.Type/resource\",\n        \"2024-01-01\",\n      );\n      expect(config).toBeUndefined();\n    });\n  });\n\n  describe(\"Migration Analysis\", () => {\n    beforeEach(() => {\n      // Create versions with breaking changes\n      const version1 = createTestVersionConfig(\"2024-01-01\");\n      const version2 = {\n        ...createTestVersionConfig(\"2024-06-01\"),\n        breakingChanges: [\n          {\n            changeType: BreakingChangeType.PROPERTY_REMOVED,\n            property: \"oldProperty\",\n            description: \"Property oldProperty was removed\",\n            migrationPath: \"Use newProperty instead\",\n          },\n        ],\n      };\n      const version3 = {\n        ...createTestVersionConfig(\"2024-12-01\"),\n        breakingChanges: [\n          {\n            changeType: BreakingChangeType.PROPERTY_TYPE_CHANGED,\n            property: \"name\",\n            oldValue: \"string\",\n            newValue: \"object\",\n            description: \"Property name type changed from string to object\",\n            migrationPath: \"Update name property to use object format\",\n          },\n          {\n            changeType: BreakingChangeType.SCHEMA_RESTRUCTURED,\n            description: \"Schema was completely restructured\",\n            migrationPath: \"Follow migration guide for complete schema changes\",\n          },\n        ],\n      };\n\n      manager.registerResourceType(TEST_RESOURCE_TYPE, [\n        version1,\n        version2,\n        version3,\n      ]);\n    });\n\n    it(\"should analyze migration between compatible versions\", () => {\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-01-01\",\n      );\n\n      expect(analysis.fromVersion).toBe(\"2024-01-01\");\n      expect(analysis.toVersion).toBe(\"2024-01-01\");\n      expect(analysis.compatible).toBe(true);\n      expect(analysis.breakingChanges).toHaveLength(0);\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.LOW);\n      expect(analysis.automaticUpgradePossible).toBe(true);\n    });\n\n    it(\"should analyze migration with breaking changes\", () => {\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-06-01\",\n      );\n\n      expect(analysis.fromVersion).toBe(\"2024-01-01\");\n      expect(analysis.toVersion).toBe(\"2024-06-01\");\n      expect(analysis.compatible).toBe(false);\n      expect(analysis.breakingChanges).toHaveLength(1);\n      expect(analysis.breakingChanges[0].changeType).toBe(\n        BreakingChangeType.PROPERTY_REMOVED,\n      );\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.LOW);\n      expect(analysis.automaticUpgradePossible).toBe(false);\n    });\n\n    it(\"should analyze migration with multiple breaking changes\", () => {\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-12-01\",\n      );\n\n      expect(analysis.fromVersion).toBe(\"2024-01-01\");\n      expect(analysis.toVersion).toBe(\"2024-12-01\");\n      expect(analysis.compatible).toBe(false);\n      expect(analysis.breakingChanges).toHaveLength(3); // All breaking changes from versions 2 and 3\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.BREAKING);\n      expect(analysis.automaticUpgradePossible).toBe(false);\n    });\n\n    it(\"should throw error for invalid version migration analysis\", () => {\n      expect(() => {\n        manager.analyzeMigration(\n          TEST_RESOURCE_TYPE,\n          \"invalid-version\",\n          \"2024-01-01\",\n        );\n      }).toThrow(\"Source version 'invalid-version' not found\");\n\n      expect(() => {\n        manager.analyzeMigration(\n          TEST_RESOURCE_TYPE,\n          \"2024-01-01\",\n          \"invalid-version\",\n        );\n      }).toThrow(\"Target version 'invalid-version' not found\");\n\n      expect(() => {\n        manager.analyzeMigration(\n          \"Unregistered.Type/resource\",\n          \"2024-01-01\",\n          \"2024-06-01\",\n        );\n      }).toThrow(\n        \"Source version '2024-01-01' not found for resource type 'Unregistered.Type/resource'\",\n      );\n    });\n  });\n\n  describe(\"Version Lifecycle Management\", () => {\n    beforeEach(() => {\n      const deprecatedVersion = {\n        ...createTestVersionConfig(\n          \"2024-01-01\",\n          VersionSupportLevel.DEPRECATED,\n        ),\n        sunsetDate: \"2025-01-01\",\n      };\n\n      const activeVersion = createTestVersionConfig(\n        \"2024-06-01\",\n        VersionSupportLevel.ACTIVE,\n      );\n\n      manager.registerResourceType(TEST_RESOURCE_TYPE, [\n        deprecatedVersion,\n        activeVersion,\n      ]);\n    });\n\n    it(\"should return version lifecycle information\", () => {\n      const lifecycle = manager.versionLifecycle(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n      );\n\n      expect(lifecycle).toBeDefined();\n      expect(lifecycle!.version).toBe(\"2024-01-01\");\n      expect(lifecycle!.phase).toBe(VersionSupportLevel.DEPRECATED);\n      expect(lifecycle!.transitionDate).toBe(\"2024-01-01\");\n      expect(lifecycle!.nextPhase).toBe(VersionSupportLevel.SUNSET);\n      expect(lifecycle!.estimatedSunsetDate).toBe(\"2025-01-01\");\n    });\n\n    it(\"should return undefined for non-existent version lifecycle\", () => {\n      const lifecycle = manager.versionLifecycle(\n        TEST_RESOURCE_TYPE,\n        \"invalid-version\",\n      );\n      expect(lifecycle).toBeUndefined();\n    });\n\n    it(\"should generate migration warnings for deprecated versions\", () => {\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-06-01\",\n      );\n\n      expect(analysis.warnings).toContain(\n        \"Source version '2024-01-01' is deprecated. Consider migrating to avoid future compatibility issues.\",\n      );\n    });\n  });\n\n  describe(\"Version Constraints and Selection\", () => {\n    beforeEach(() => {\n      const versions = [\n        createTestVersionConfig(\"2023-01-01\", VersionSupportLevel.DEPRECATED),\n        createTestVersionConfig(\"2024-01-01\", VersionSupportLevel.MAINTENANCE),\n        createTestVersionConfig(\"2024-06-01\", VersionSupportLevel.ACTIVE),\n        createTestVersionConfig(\"2024-12-01\", VersionSupportLevel.ACTIVE),\n      ];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n    });\n\n    it(\"should find version by support level constraint\", () => {\n      const constraints: VersionConstraints = {\n        supportLevel: VersionSupportLevel.ACTIVE,\n      };\n\n      const version = manager._findVersionByConstraints(\n        TEST_RESOURCE_TYPE,\n        constraints,\n      );\n      expect(version).toBe(\"2024-12-01\"); // Latest active version\n    });\n\n    it(\"should find version excluding deprecated\", () => {\n      const constraints: VersionConstraints = {\n        excludeDeprecated: true,\n      };\n\n      const version = manager._findVersionByConstraints(\n        TEST_RESOURCE_TYPE,\n        constraints,\n      );\n      expect(version).toBe(\"2024-12-01\"); // Latest non-deprecated version\n    });\n\n    it(\"should find version with date constraint\", () => {\n      const constraints: VersionConstraints = {\n        notOlderThan: new Date(\"2024-06-01\"),\n      };\n\n      const version = manager._findVersionByConstraints(\n        TEST_RESOURCE_TYPE,\n        constraints,\n      );\n      expect(version).toBe(\"2024-12-01\"); // Latest version after date\n    });\n\n    it(\"should return undefined when no version matches constraints\", () => {\n      const constraints: VersionConstraints = {\n        supportLevel: \"non-existent-level\",\n      };\n\n      const version = manager._findVersionByConstraints(\n        TEST_RESOURCE_TYPE,\n        constraints,\n      );\n      expect(version).toBeUndefined();\n    });\n\n    it(\"should return undefined for unregistered resource type\", () => {\n      const constraints: VersionConstraints = {\n        supportLevel: VersionSupportLevel.ACTIVE,\n      };\n\n      const version = manager._findVersionByConstraints(\n        \"Unregistered.Type/resource\",\n        constraints,\n      );\n      expect(version).toBeUndefined();\n    });\n  });\n\n  describe(\"Migration Effort Calculation\", () => {\n    it(\"should calculate low effort for no breaking changes\", () => {\n      const versions = [\n        createTestVersionConfig(\"2024-01-01\"),\n        createTestVersionConfig(\"2024-06-01\"),\n      ];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-06-01\",\n      );\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.LOW);\n    });\n\n    it(\"should calculate medium effort for few breaking changes\", () => {\n      const version1 = createTestVersionConfig(\"2024-01-01\");\n      const version2 = {\n        ...createTestVersionConfig(\"2024-06-01\"),\n        breakingChanges: [\n          {\n            changeType: BreakingChangeType.PROPERTY_RENAMED,\n            property: \"oldName\",\n            newValue: \"newName\",\n            description: \"Property renamed\",\n          },\n          {\n            changeType: BreakingChangeType.PROPERTY_RENAMED,\n            property: \"oldName2\",\n            newValue: \"newName2\",\n            description: \"Another property renamed\",\n          },\n          {\n            changeType: BreakingChangeType.PROPERTY_RENAMED,\n            property: \"oldName3\",\n            newValue: \"newName3\",\n            description: \"Third property renamed\",\n          },\n        ],\n      };\n\n      manager.registerResourceType(TEST_RESOURCE_TYPE, [version1, version2]);\n\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-06-01\",\n      );\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.MEDIUM);\n    });\n\n    it(\"should calculate breaking effort for schema restructure\", () => {\n      const version1 = createTestVersionConfig(\"2024-01-01\");\n      const version2 = {\n        ...createTestVersionConfig(\"2024-06-01\"),\n        breakingChanges: [\n          {\n            changeType: BreakingChangeType.SCHEMA_RESTRUCTURED,\n            description: \"Complete schema restructure\",\n          },\n        ],\n      };\n\n      manager.registerResourceType(TEST_RESOURCE_TYPE, [version1, version2]);\n\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-06-01\",\n      );\n      expect(analysis.estimatedEffort).toBe(MigrationEffort.BREAKING);\n    });\n  });\n\n  describe(\"Multiple Resource Types\", () => {\n    it(\"should handle multiple resource types independently\", () => {\n      const versions1 = [createTestVersionConfig(\"2024-01-01\")];\n      const versions2 = [\n        {\n          ...createTestVersionConfig(\"2024-06-01\"),\n          schema: {\n            ...createTestSchema(\"2024-06-01\"),\n            resourceType: TEST_RESOURCE_TYPE_2,\n          },\n        },\n      ];\n\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions1);\n      manager.registerResourceType(TEST_RESOURCE_TYPE_2, versions2);\n\n      expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE);\n      expect(manager.registeredResourceTypes()).toContain(TEST_RESOURCE_TYPE_2);\n\n      expect(manager.latestVersion(TEST_RESOURCE_TYPE)).toBe(\"2024-01-01\");\n      expect(manager.latestVersion(TEST_RESOURCE_TYPE_2)).toBe(\"2024-06-01\");\n    });\n\n    it(\"should return all registered resource types\", () => {\n      const versions = [createTestVersionConfig(\"2024-01-01\")];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n\n      const resourceTypes = manager.registeredResourceTypes();\n      expect(Array.isArray(resourceTypes)).toBe(true);\n      expect(resourceTypes.length).toBeGreaterThan(0);\n    });\n  });\n\n  describe(\"Error Handling and Edge Cases\", () => {\n    it(\"should handle empty version arrays gracefully\", () => {\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, []);\n      }).toThrow(\"Versions array cannot be empty\");\n    });\n\n    it(\"should handle null/undefined version configurations\", () => {\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [null as any]);\n      }).toThrow();\n    });\n\n    it(\"should handle invalid schema objects\", () => {\n      const invalidVersionConfig = {\n        version: \"2024-01-01\",\n        schema: null as any,\n        supportLevel: VersionSupportLevel.ACTIVE,\n        releaseDate: \"2024-01-01\",\n      };\n\n      expect(() => {\n        manager.registerResourceType(TEST_RESOURCE_TYPE, [\n          invalidVersionConfig,\n        ]);\n      }).toThrow(\"Schema is required\");\n    });\n\n    it(\"should handle migration analysis with same from/to versions\", () => {\n      const versions = [createTestVersionConfig(\"2024-01-01\")];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n\n      const analysis = manager.analyzeMigration(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n        \"2024-01-01\",\n      );\n      expect(analysis.compatible).toBe(true);\n      expect(analysis.breakingChanges).toHaveLength(0);\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant method signatures\", () => {\n      // Test that all public methods are accessible and have expected signatures\n      expect(typeof manager.registerResourceType).toBe(\"function\");\n      expect(typeof manager.latestVersion).toBe(\"function\");\n      expect(typeof manager.versionConfig).toBe(\"function\");\n      expect(typeof manager.supportedVersions).toBe(\"function\");\n      expect(typeof manager.analyzeMigration).toBe(\"function\");\n      expect(typeof manager.validateVersionSupport).toBe(\"function\");\n      expect(typeof manager.registeredResourceTypes).toBe(\"function\");\n      expect(typeof manager.versionLifecycle).toBe(\"function\");\n    });\n\n    it(\"should return JSII-compliant types\", () => {\n      const versions = [createTestVersionConfig(\"2024-01-01\")];\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n\n      // Test return types\n      const latest = manager.latestVersion(TEST_RESOURCE_TYPE);\n      expect(typeof latest === \"string\" || latest === undefined).toBe(true);\n\n      const supportedVersions = manager.supportedVersions(TEST_RESOURCE_TYPE);\n      expect(Array.isArray(supportedVersions)).toBe(true);\n\n      const isSupported = manager.validateVersionSupport(\n        TEST_RESOURCE_TYPE,\n        \"2024-01-01\",\n      );\n      expect(typeof isSupported).toBe(\"boolean\");\n\n      const resourceTypes = manager.registeredResourceTypes();\n      expect(Array.isArray(resourceTypes)).toBe(true);\n    });\n  });\n});\n"]}