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

package/lib/azure-virtualmachine/test/virtual-machine.spec.js

@@ -0,0 +1,1032 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified VirtualMachine implementation
+ *
+ * This test suite validates the unified VirtualMachine class that replaces all
+ * version-specific implementations using the VersionedAzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, and full backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const virtual_machine_1 = require("../lib/virtual-machine");
+const virtual_machine_schemas_1 = require("../lib/virtual-machine-schemas");
+describe("VirtualMachine - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure Virtual Machine schemas are registered
+        try {
+            manager.registerResourceType(virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE, virtual_machine_schemas_1.ALL_VIRTUAL_MACHINE_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create virtual machine with automatic latest version resolution", () => {
+            const props = {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: {
+                    vmSize: "Standard_D2s_v3",
+                },
+                storageProfile: {
+                    imageReference: {
+                        publisher: "Canonical",
+                        offer: "UbuntuServer",
+                        sku: "18.04-LTS",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                        managedDisk: {
+                            storageAccountType: "Premium_LRS",
+                        },
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [
+                        {
+                            id: "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic",
+                        },
+                    ],
+                },
+            };
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", props);
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+            expect(vm.resolvedApiVersion).toBe("2025-04-01"); // Latest version
+            expect(vm.props).toBe(props);
+            expect(vm.name).toBe("test-vm");
+            expect(vm.location).toBe("eastus");
+        });
+        it("should create virtual machine with explicit version pinning", () => {
+            const props = {
+                name: "test-vm-pinned",
+                location: "westus",
+                apiVersion: "2024-07-01",
+                hardwareProfile: {
+                    vmSize: "Standard_D2s_v3",
+                },
+                storageProfile: {
+                    imageReference: {
+                        publisher: "Canonical",
+                        offer: "UbuntuServer",
+                        sku: "18.04-LTS",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [
+                        {
+                            id: "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic",
+                        },
+                    ],
+                },
+                tags: { environment: "test" },
+            };
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", props);
+            expect(vm.resolvedApiVersion).toBe("2024-07-01");
+            expect(vm.tags).toEqual({ environment: "test" });
+        });
+        it("should create virtual machine with all optional properties", () => {
+            const props = {
+                name: "test-vm-full",
+                location: "centralus",
+                hardwareProfile: {
+                    vmSize: "Standard_D4s_v3",
+                },
+                storageProfile: {
+                    imageReference: {
+                        publisher: "Canonical",
+                        offer: "UbuntuServer",
+                        sku: "18.04-LTS",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                        managedDisk: {
+                            storageAccountType: "Premium_LRS",
+                        },
+                    },
+                    dataDisks: [
+                        {
+                            lun: 0,
+                            createOption: "Empty",
+                            diskSizeGB: 512,
+                        },
+                    ],
+                },
+                osProfile: {
+                    computerName: "testvm",
+                    adminUsername: "azureuser",
+                    linuxConfiguration: {
+                        disablePasswordAuthentication: true,
+                        ssh: {
+                            publicKeys: [
+                                {
+                                    path: "/home/azureuser/.ssh/authorized_keys",
+                                    keyData: "ssh-rsa AAAAB3NzaC1yc2E...",
+                                },
+                            ],
+                        },
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [
+                        {
+                            id: "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic",
+                        },
+                    ],
+                },
+                identity: {
+                    type: "SystemAssigned",
+                },
+                zones: ["1", "2"],
+                priority: "Regular",
+                tags: {
+                    environment: "production",
+                    project: "cdktf-constructs",
+                },
+                diagnosticsProfile: {
+                    bootDiagnostics: {
+                        enabled: true,
+                    },
+                },
+                ignoreChanges: ["tags", "osProfile.adminPassword"],
+                enableValidation: true,
+                enableMigrationAnalysis: true,
+            };
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", props);
+            expect(vm.props.tags).toEqual(props.tags);
+            expect(vm.props.identity).toEqual(props.identity);
+            expect(vm.props.zones).toEqual(props.zones);
+            expect(vm.props.ignoreChanges).toEqual(props.ignoreChanges);
+        });
+        it("should create Windows VM with Windows configuration", () => {
+            const props = {
+                name: "windows-vm",
+                location: "eastus",
+                hardwareProfile: {
+                    vmSize: "Standard_D2s_v3",
+                },
+                storageProfile: {
+                    imageReference: {
+                        publisher: "MicrosoftWindowsServer",
+                        offer: "WindowsServer",
+                        sku: "2022-datacenter",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                    },
+                },
+                osProfile: {
+                    computerName: "winvm",
+                    adminUsername: "azureuser",
+                    adminPassword: "P@ssw0rd1234!",
+                    windowsConfiguration: {
+                        provisionVMAgent: true,
+                        enableAutomaticUpdates: true,
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [
+                        {
+                            id: "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic",
+                        },
+                    ],
+                },
+                licenseType: "Windows_Server",
+            };
+            const vm = new virtual_machine_1.VirtualMachine(stack, "WindowsVM", props);
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+            expect(vm.props.licenseType).toBe("Windows_Server");
+            expect(vm.props.osProfile?.windowsConfiguration).toBeDefined();
+        });
+        it("should create Spot VM with billing profile", () => {
+            const props = {
+                name: "spot-vm",
+                location: "eastus",
+                priority: "Spot",
+                evictionPolicy: "Deallocate",
+                billingProfile: {
+                    maxPrice: -1,
+                },
+                hardwareProfile: {
+                    vmSize: "Standard_D2s_v3",
+                },
+                storageProfile: {
+                    osDisk: {
+                        createOption: "FromImage",
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [
+                        {
+                            id: "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic",
+                        },
+                    ],
+                },
+            };
+            const vm = new virtual_machine_1.VirtualMachine(stack, "SpotVM", props);
+            expect(vm.props.priority).toBe("Spot");
+            expect(vm.props.evictionPolicy).toBe("Deallocate");
+            expect(vm.props.billingProfile?.maxPrice).toBe(-1);
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.resolvedApiVersion).toBe("2025-04-01");
+            expect(vm.latestVersion()).toBe("2025-04-01");
+        });
+        it("should support all registered API versions", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            const supportedVersions = vm.supportedVersions();
+            expect(supportedVersions).toContain("2024-07-01");
+            expect(supportedVersions).toContain("2024-11-01");
+            expect(supportedVersions).toContain("2024-07-01");
+        });
+        it("should validate version support", () => {
+            // Valid version
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "ValidVersion", {
+                    name: "test-vm",
+                    location: "eastus",
+                    apiVersion: "2024-11-01",
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+            }).not.toThrow();
+            // Invalid version
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "InvalidVersion", {
+                    name: "test-vm",
+                    location: "eastus",
+                    apiVersion: "2026-01-01",
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+            }).toThrow("Unsupported API version '2026-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                apiVersion: "2024-07-01",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.schema).toBeDefined();
+            expect(vm.schema.resourceType).toBe(virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE);
+            expect(vm.schema.version).toBe("2024-07-01");
+            expect(vm.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.versionConfig).toBeDefined();
+            expect(vm.versionConfig.version).toBe("2025-04-01");
+            expect(vm.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Property Validation", () => {
+        it("should validate properties when validation is enabled", () => {
+            const props = {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                enableValidation: true,
+            };
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "TestVM", props);
+            }).not.toThrow();
+        });
+        it("should have validation results for valid properties", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "valid-vm-name",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                enableValidation: true,
+            });
+            expect(vm.validationResult).toBeDefined();
+            expect(vm.validationResult.valid).toBe(true);
+            expect(vm.validationResult.errors).toHaveLength(0);
+        });
+        it("should skip validation when disabled", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                enableValidation: false,
+            });
+            expect(vm).toBeDefined();
+        });
+    });
+    describe("Migration Analysis", () => {
+        it("should perform migration analysis between versions", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                apiVersion: "2024-07-01",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            const analysis = vm.analyzeMigrationTo("2025-04-01");
+            expect(analysis).toBeDefined();
+            expect(analysis.fromVersion).toBe("2024-07-01");
+            expect(analysis.toVersion).toBe("2025-04-01");
+            expect(analysis.compatible).toBe(true);
+        });
+        it("should skip migration analysis when disabled", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                enableMigrationAnalysis: false,
+            });
+            expect(vm.migrationAnalysis).toBeUndefined();
+        });
+    });
+    describe("Resource Creation and Body", () => {
+        it("should create correct resource body", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "westus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: {
+                    imageReference: {
+                        publisher: "Canonical",
+                        offer: "UbuntuServer",
+                        sku: "18.04-LTS",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                    },
+                },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                tags: { environment: "test" },
+                identity: { type: "SystemAssigned" },
+            });
+            expect(vm).toBeDefined();
+            expect(vm.props.tags).toEqual({ environment: "test" });
+            expect(vm.props.identity).toEqual({ type: "SystemAssigned" });
+        });
+        it("should handle minimal resource creation", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "MinimalVM", {
+                name: "minimal-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_B1s" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm).toBeDefined();
+            expect(vm.name).toBe("minimal-vm");
+            expect(vm.location).toBe("eastus");
+            expect(vm.vmSize).toBe("Standard_B1s");
+        });
+        it("should create Terraform outputs", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm-outputs",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vm.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vm.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vm.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vm.vmIdOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+    });
+    describe("Public Methods and Properties", () => {
+        let vm;
+        beforeEach(() => {
+            vm = new virtual_machine_1.VirtualMachine(stack, "TestVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: {
+                    osDisk: { createOption: "FromImage" },
+                },
+                osProfile: {
+                    computerName: "testcomputer",
+                    adminUsername: "azureuser",
+                },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                tags: { environment: "test" },
+            });
+        });
+        it("should have correct id format", () => {
+            expect(vm.id).toMatch(/^\$\{.*\.id\}$/);
+        });
+        it("should have vmId property", () => {
+            expect(vm.vmId).toMatch(/^\$\{.*\.output\.properties\.vmId\}$/);
+        });
+        it("should have provisioningState property", () => {
+            expect(vm.provisioningState).toMatch(/^\$\{.*\.output\.properties\.provisioningState\}$/);
+        });
+        it("should have computerName property", () => {
+            expect(vm.computerName).toBe("testcomputer");
+        });
+        it("should have vmSize property", () => {
+            expect(vm.vmSize).toBe("Standard_D2s_v3");
+        });
+        it("should support tag management", () => {
+            // Test addTag
+            vm.addTag("newTag", "newValue");
+            expect(vm.props.tags.newTag).toBe("newValue");
+            expect(vm.props.tags.environment).toBe("test");
+            // Test removeTag
+            vm.removeTag("environment");
+            expect(vm.props.tags.environment).toBeUndefined();
+            expect(vm.props.tags.newTag).toBe("newValue");
+        });
+        it("should add tags when no tags exist", () => {
+            const vmNoTags = new virtual_machine_1.VirtualMachine(stack, "NoTagsVM", {
+                name: "no-tags-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            vmNoTags.addTag("firstTag", "firstValue");
+            expect(vmNoTags.props.tags.firstTag).toBe("firstValue");
+        });
+        it("should handle removing non-existent tags gracefully", () => {
+            expect(() => {
+                vm.removeTag("nonExistentTag");
+            }).not.toThrow();
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "IgnoreChangesVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                ignoreChanges: ["tags", "osProfile.adminPassword"],
+            });
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+        });
+        it("should filter out invalid ignore changes", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "FilteredIgnoreVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                ignoreChanges: ["tags", "name", "location"], // name should be filtered
+            });
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+        });
+        it("should handle empty ignore changes array", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "EmptyIgnoreVM", {
+                name: "test-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                ignoreChanges: [],
+            });
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2024-07-01", "2024-11-01", "2025-04-01"];
+            versions.forEach((version) => {
+                const vm = new virtual_machine_1.VirtualMachine(stack, `VM-${version.replace(/-/g, "")}`, {
+                    name: `test-vm-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+                expect(vm.resolvedApiVersion).toBe(version);
+                expect(vm.schema.version).toBe(version);
+            });
+        });
+        it("should handle schema differences across versions", () => {
+            const versions = ["2024-07-01", "2024-11-01", "2025-04-01"];
+            versions.forEach((version) => {
+                const vm = new virtual_machine_1.VirtualMachine(stack, `Schema-${version.replace(/-/g, "")}`, {
+                    name: `schema-test-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+                expect(vm.schema.properties.location).toBeDefined();
+                expect(vm.schema.properties.hardwareProfile).toBeDefined();
+                expect(vm.schema.properties.storageProfile).toBeDefined();
+                expect(vm.schema.properties.networkProfile).toBeDefined();
+            });
+        });
+    });
+    describe("VM Configuration Scenarios", () => {
+        it("should support VM with data disks", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "DataDisksVM", {
+                name: "data-disks-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: {
+                    osDisk: { createOption: "FromImage" },
+                    dataDisks: [
+                        {
+                            lun: 0,
+                            createOption: "Empty",
+                            diskSizeGB: 512,
+                            managedDisk: {
+                                storageAccountType: "Premium_LRS",
+                            },
+                        },
+                        {
+                            lun: 1,
+                            createOption: "Empty",
+                            diskSizeGB: 1024,
+                            managedDisk: {
+                                storageAccountType: "Premium_LRS",
+                            },
+                        },
+                    ],
+                },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.props.storageProfile.dataDisks).toHaveLength(2);
+            expect(vm.props.storageProfile.dataDisks[0].lun).toBe(0);
+            expect(vm.props.storageProfile.dataDisks[1].lun).toBe(1);
+        });
+        it("should support VM with managed identity", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "ManagedIdentityVM", {
+                name: "identity-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                identity: {
+                    type: "UserAssigned",
+                    userAssignedIdentities: {
+                        "/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-identity": {},
+                    },
+                },
+            });
+            expect(vm.props.identity?.type).toBe("UserAssigned");
+            expect(vm.props.identity?.userAssignedIdentities).toBeDefined();
+        });
+        it("should support VM in availability zones", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "ZonalVM", {
+                name: "zonal-vm",
+                location: "eastus",
+                zones: ["1"],
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(vm.props.zones).toEqual(["1"]);
+        });
+        it("should support VM with boot diagnostics", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "BootDiagVM", {
+                name: "bootdiag-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                diagnosticsProfile: {
+                    bootDiagnostics: {
+                        enabled: true,
+                        storageUri: "https://teststorage.blob.core.windows.net",
+                    },
+                },
+            });
+            expect(vm.props.diagnosticsProfile?.bootDiagnostics?.enabled).toBe(true);
+        });
+        it("should support VM with security profile", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "SecureVM", {
+                name: "secure-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                securityProfile: {
+                    uefiSettings: {
+                        secureBootEnabled: true,
+                        vTpmEnabled: true,
+                    },
+                    securityType: "TrustedLaunch",
+                },
+            });
+            expect(vm.props.securityProfile?.uefiSettings?.secureBootEnabled).toBe(true);
+            expect(vm.props.securityProfile?.securityType).toBe("TrustedLaunch");
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid API versions gracefully", () => {
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "InvalidAPI", {
+                    name: "test-vm",
+                    location: "eastus",
+                    apiVersion: "invalid-version",
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+            }).toThrow("Unsupported API version 'invalid-version'");
+        });
+        it("should handle schema registration errors gracefully", () => {
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "SchemaTest", {
+                    name: "test-vm",
+                    location: "eastus",
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+            }).not.toThrow();
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant constructor", () => {
+            expect(() => {
+                new virtual_machine_1.VirtualMachine(stack, "JsiiTest", {
+                    name: "jsii-test",
+                    location: "eastus",
+                    hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                    storageProfile: { osDisk: { createOption: "FromImage" } },
+                    networkProfile: {
+                        networkInterfaces: [{ id: "/test/nic" }],
+                    },
+                });
+            }).not.toThrow();
+        });
+        it("should have JSII-compliant properties", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "JsiiProps", {
+                name: "jsii-props",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(typeof vm.id).toBe("string");
+            expect(typeof vm.name).toBe("string");
+            expect(typeof vm.location).toBe("string");
+            expect(typeof vm.tags).toBe("object");
+            expect(typeof vm.resolvedApiVersion).toBe("string");
+            expect(typeof vm.vmId).toBe("string");
+            expect(typeof vm.vmSize).toBe("string");
+        });
+        it("should have JSII-compliant methods", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "JsiiMethods", {
+                name: "jsii-methods",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+            });
+            expect(typeof vm.addTag).toBe("function");
+            expect(typeof vm.removeTag).toBe("function");
+            expect(typeof vm.latestVersion).toBe("function");
+            expect(typeof vm.supportedVersions).toBe("function");
+            expect(typeof vm.analyzeMigrationTo).toBe("function");
+        });
+        it("should serialize complex objects correctly", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "JsiiSerialization", {
+                name: "jsii-serialization",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                tags: {
+                    complex: "value",
+                    nested: "data",
+                },
+            });
+            // Should be able to serialize validation results
+            expect(() => JSON.stringify(vm.validationResult)).not.toThrow();
+            // Should be able to serialize schema
+            expect(() => JSON.stringify(vm.schema)).not.toThrow();
+            // Should be able to serialize version config
+            expect(() => JSON.stringify(vm.versionConfig)).not.toThrow();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new virtual_machine_1.VirtualMachine(stack, "SynthTest", {
+                name: "synth-test",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should work in complex CDK constructs", () => {
+            class ComplexConstruct extends cdktf.TerraformStack {
+                constructor(scope, id) {
+                    super(scope, id);
+                    // Create multiple VMs
+                    const vm1 = new virtual_machine_1.VirtualMachine(this, "PrimaryVM", {
+                        name: "primary-vm",
+                        location: "eastus",
+                        hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                        storageProfile: { osDisk: { createOption: "FromImage" } },
+                        networkProfile: {
+                            networkInterfaces: [{ id: "/test/nic1" }],
+                        },
+                        tags: { tier: "primary" },
+                    });
+                    const vm2 = new virtual_machine_1.VirtualMachine(this, "SecondaryVM", {
+                        name: "secondary-vm",
+                        location: "westus",
+                        apiVersion: "2024-07-01",
+                        hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                        storageProfile: { osDisk: { createOption: "FromImage" } },
+                        networkProfile: {
+                            networkInterfaces: [{ id: "/test/nic2" }],
+                        },
+                        tags: { tier: "secondary" },
+                    });
+                    // Create outputs that reference the VMs
+                    new cdktf.TerraformOutput(this, "PrimaryVMId", {
+                        value: vm1.id,
+                    });
+                    new cdktf.TerraformOutput(this, "SecondaryVMId", {
+                        value: vm2.id,
+                    });
+                }
+            }
+            expect(() => {
+                new ComplexConstruct(app, "ComplexStack");
+            }).not.toThrow();
+        });
+        it("should handle multiple VMs in the same stack", () => {
+            const vm1 = new virtual_machine_1.VirtualMachine(stack, "VM1", {
+                name: "vm-1",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic1" }],
+                },
+            });
+            const vm2 = new virtual_machine_1.VirtualMachine(stack, "VM2", {
+                name: "vm-2",
+                location: "westus",
+                apiVersion: "2024-11-01",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic2" }],
+                },
+            });
+            expect(vm1.resolvedApiVersion).toBe("2025-04-01");
+            expect(vm2.resolvedApiVersion).toBe("2024-11-01");
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("VirtualMachine Monitoring", () => {
+        it("should return default monitoring configuration with all alerts enabled", () => {
+            const config = virtual_machine_1.VirtualMachine.defaultMonitoring("action-group-id", "workspace-id");
+            expect(config.enabled).toBe(true);
+            expect(config.diagnosticSettings).toBeDefined();
+            expect(config.diagnosticSettings?.workspaceId).toBe("workspace-id");
+            expect(config.diagnosticSettings?.logs).toEqual([
+                { categoryGroup: "allLogs", enabled: true },
+            ]);
+            expect(config.diagnosticSettings?.metrics).toEqual([
+                { category: "AllMetrics", enabled: true },
+            ]);
+            expect(config.metricAlerts).toHaveLength(3);
+            // Verify high-cpu-alert
+            const cpuAlert = config.metricAlerts?.find((a) => a.name === "high-cpu-alert");
+            expect(cpuAlert).toBeDefined();
+            expect(cpuAlert?.severity).toBe(2);
+            expect((cpuAlert?.criteria).threshold).toBe(80);
+            expect((cpuAlert?.criteria).metricName).toBe("Percentage CPU");
+            expect((cpuAlert?.criteria).operator).toBe("GreaterThan");
+            // Verify low-memory-alert
+            const memoryAlert = config.metricAlerts?.find((a) => a.name === "low-memory-alert");
+            expect(memoryAlert).toBeDefined();
+            expect(memoryAlert?.severity).toBe(2);
+            expect((memoryAlert?.criteria).threshold).toBe(1073741824);
+            expect((memoryAlert?.criteria).metricName).toBe("Available Memory Bytes");
+            expect((memoryAlert?.criteria).operator).toBe("LessThan");
+            // Verify high-disk-queue-alert
+            const diskAlert = config.metricAlerts?.find((a) => a.name === "high-disk-queue-alert");
+            expect(diskAlert).toBeDefined();
+            expect(diskAlert?.severity).toBe(2);
+            expect((diskAlert?.criteria).threshold).toBe(32);
+            expect((diskAlert?.criteria).metricName).toBe("OS Disk Queue Depth");
+            expect((diskAlert?.criteria).operator).toBe("GreaterThan");
+            // Verify activity log alerts
+            expect(config.activityLogAlerts).toHaveLength(1);
+            const deletionAlert = config.activityLogAlerts?.[0];
+            expect(deletionAlert?.name).toBe("vm-deletion-alert");
+            expect(deletionAlert?.condition.allOf).toEqual([
+                {
+                    field: "operationName",
+                    equalsValue: "Microsoft.Compute/virtualMachines/delete",
+                },
+            ]);
+        });
+        it("should return monitoring configuration without diagnostic settings when workspace ID not provided", () => {
+            const config = virtual_machine_1.VirtualMachine.defaultMonitoring("action-group-id");
+            expect(config.enabled).toBe(true);
+            expect(config.diagnosticSettings).toBeUndefined();
+            expect(config.metricAlerts).toHaveLength(3);
+            expect(config.activityLogAlerts).toHaveLength(1);
+        });
+        it("should customize thresholds and severities", () => {
+            const config = virtual_machine_1.VirtualMachine.defaultMonitoring("action-group-id", "workspace-id", {
+                cpuThreshold: 90,
+                memoryThreshold: 524288000,
+                cpuAlertSeverity: 1,
+            });
+            const cpuAlert = config.metricAlerts?.find((a) => a.name === "high-cpu-alert");
+            expect((cpuAlert?.criteria).threshold).toBe(90);
+            expect(cpuAlert?.severity).toBe(1);
+            const memoryAlert = config.metricAlerts?.find((a) => a.name === "low-memory-alert");
+            expect((memoryAlert?.criteria).threshold).toBe(524288000);
+        });
+        it("should disable specific alerts when requested", () => {
+            const config = virtual_machine_1.VirtualMachine.defaultMonitoring("action-group-id", "workspace-id", {
+                enableCpuAlert: false,
+                enableDiskQueueAlert: false,
+                enableDeletionAlert: false,
+            });
+            expect(config.metricAlerts).toHaveLength(1);
+            const memoryAlert = config.metricAlerts?.find((a) => a.name === "low-memory-alert");
+            expect(memoryAlert).toBeDefined();
+            const cpuAlert = config.metricAlerts?.find((a) => a.name === "high-cpu-alert");
+            expect(cpuAlert).toBeUndefined();
+            const diskAlert = config.metricAlerts?.find((a) => a.name === "high-disk-queue-alert");
+            expect(diskAlert).toBeUndefined();
+            expect(config.activityLogAlerts).toBeUndefined();
+        });
+        it("should create VM with monitoring configuration", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "MonitoredVM", {
+                name: "monitored-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                monitoring: virtual_machine_1.VirtualMachine.defaultMonitoring("action-group-id", "workspace-id"),
+            });
+            expect(vm).toBeDefined();
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+            // Verify VM resource exists
+            const azapiResources = Object.keys(stackConfig.resource.azapi_resource);
+            const vmResource = azapiResources.find((key) => key.includes("MonitoredVM"));
+            expect(vmResource).toBeDefined();
+        });
+        it("should create VM without monitoring when disabled", () => {
+            const vm = new virtual_machine_1.VirtualMachine(stack, "UnmonitoredVM", {
+                name: "unmonitored-vm",
+                location: "eastus",
+                hardwareProfile: { vmSize: "Standard_D2s_v3" },
+                storageProfile: { osDisk: { createOption: "FromImage" } },
+                networkProfile: {
+                    networkInterfaces: [{ id: "/test/nic" }],
+                },
+                monitoring: { enabled: false },
+            });
+            expect(vm).toBeDefined();
+            expect(vm).toBeInstanceOf(virtual_machine_1.VirtualMachine);
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            // Verify no metric alerts are created
+            const metricAlerts = stackConfig.resource?.azapi_resource
+                ? Object.keys(stackConfig.resource.azapi_resource).filter((key) => key.includes("metric-alert"))
+                : [];
+            expect(metricAlerts.length).toBe(0);
+            // Verify no diagnostic settings are created
+            const diagnosticSettings = stackConfig.resource?.azapi_resource
+                ? Object.keys(stackConfig.resource.azapi_resource).filter((key) => key.includes("diagnostic"))
+                : [];
+            expect(diagnosticSettings.length).toBe(0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-machine.spec.js","sourceRoot":"","sources":["../../../src/azure-virtualmachine/test/virtual-machine.spec.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAEH,iCAAgC;AAChC,+BAA+B;AAC/B,kGAA6F;AAC7F,2GAAyG;AACzG,4DAA6E;AAC7E,4EAGwC;AAExC,QAAQ,CAAC,yCAAyC,EAAE,GAAG,EAAE;IACvD,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAChC,IAAI,OAA0B,CAAC;IAE/B,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QACnD,OAAO,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;QAEvC,gDAAgD;QAChD,IAAI,CAAC;YACH,OAAO,CAAC,oBAAoB,CAC1B,8CAAoB,EACpB,sDAA4B,CAC7B,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,+BAA+B;QACjC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAChD,EAAE,CAAC,wEAAwE,EAAE,GAAG,EAAE;YAChF,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE;oBACf,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,cAAc,EAAE;oBACd,cAAc,EAAE;wBACd,SAAS,EAAE,WAAW;wBACtB,KAAK,EAAE,cAAc;wBACrB,GAAG,EAAE,WAAW;wBAChB,OAAO,EAAE,QAAQ;qBAClB;oBACD,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;wBACzB,WAAW,EAAE;4BACX,kBAAkB,EAAE,aAAa;yBAClC;qBACF;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE;wBACjB;4BACE,EAAE,EAAE,mGAAmG;yBACxG;qBACF;iBACF;aACF,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAEtD,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;YAC1C,MAAM,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB;YACnE,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAChC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;YACrE,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,gBAAgB;gBACtB,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,YAAY;gBACxB,eAAe,EAAE;oBACf,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,cAAc,EAAE;oBACd,cAAc,EAAE;wBACd,SAAS,EAAE,WAAW;wBACtB,KAAK,EAAE,cAAc;wBACrB,GAAG,EAAE,WAAW;wBAChB,OAAO,EAAE,QAAQ;qBAClB;oBACD,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;qBAC1B;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE;wBACjB;4BACE,EAAE,EAAE,mGAAmG;yBACxG;qBACF;iBACF;gBACD,IAAI,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE;aAC9B,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAEtD,MAAM,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjD,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,WAAW;gBACrB,eAAe,EAAE;oBACf,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,cAAc,EAAE;oBACd,cAAc,EAAE;wBACd,SAAS,EAAE,WAAW;wBACtB,KAAK,EAAE,cAAc;wBACrB,GAAG,EAAE,WAAW;wBAChB,OAAO,EAAE,QAAQ;qBAClB;oBACD,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;wBACzB,WAAW,EAAE;4BACX,kBAAkB,EAAE,aAAa;yBAClC;qBACF;oBACD,SAAS,EAAE;wBACT;4BACE,GAAG,EAAE,CAAC;4BACN,YAAY,EAAE,OAAO;4BACrB,UAAU,EAAE,GAAG;yBAChB;qBACF;iBACF;gBACD,SAAS,EAAE;oBACT,YAAY,EAAE,QAAQ;oBACtB,aAAa,EAAE,WAAW;oBAC1B,kBAAkB,EAAE;wBAClB,6BAA6B,EAAE,IAAI;wBACnC,GAAG,EAAE;4BACH,UAAU,EAAE;gCACV;oCACE,IAAI,EAAE,sCAAsC;oCAC5C,OAAO,EAAE,4BAA4B;iCACtC;6BACF;yBACF;qBACF;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE;wBACjB;4BACE,EAAE,EAAE,mGAAmG;yBACxG;qBACF;iBACF;gBACD,QAAQ,EAAE;oBACR,IAAI,EAAE,gBAAgB;iBACvB;gBACD,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;gBACjB,QAAQ,EAAE,SAAS;gBACnB,IAAI,EAAE;oBACJ,WAAW,EAAE,YAAY;oBACzB,OAAO,EAAE,kBAAkB;iBAC5B;gBACD,kBAAkB,EAAE;oBAClB,eAAe,EAAE;wBACf,OAAO,EAAE,IAAI;qBACd;iBACF;gBACD,aAAa,EAAE,CAAC,MAAM,EAAE,yBAAyB,CAAC;gBAClD,gBAAgB,EAAE,IAAI;gBACtB,uBAAuB,EAAE,IAAI;aAC9B,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAEtD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAClD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC5C,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE;oBACf,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,cAAc,EAAE;oBACd,cAAc,EAAE;wBACd,SAAS,EAAE,wBAAwB;wBACnC,KAAK,EAAE,eAAe;wBACtB,GAAG,EAAE,iBAAiB;wBACtB,OAAO,EAAE,QAAQ;qBAClB;oBACD,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;qBAC1B;iBACF;gBACD,SAAS,EAAE;oBACT,YAAY,EAAE,OAAO;oBACrB,aAAa,EAAE,WAAW;oBAC1B,aAAa,EAAE,eAAe;oBAC9B,oBAAoB,EAAE;wBACpB,gBAAgB,EAAE,IAAI;wBACtB,sBAAsB,EAAE,IAAI;qBAC7B;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE;wBACjB;4BACE,EAAE,EAAE,mGAAmG;yBACxG;qBACF;iBACF;gBACD,WAAW,EAAE,gBAAgB;aAC9B,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;YAEzD,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;YAC1C,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACpD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,MAAM;gBAChB,cAAc,EAAE,YAAY;gBAC5B,cAAc,EAAE;oBACd,QAAQ,EAAE,CAAC,CAAC;iBACb;gBACD,eAAe,EAAE;oBACf,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,cAAc,EAAE;oBACd,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;qBAC1B;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE;wBACjB;4BACE,EAAE,EAAE,mGAAmG;yBACxG;qBACF;iBACF;aACF,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAEtD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;QACrC,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjD,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,iBAAiB,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC;YACjD,MAAM,CAAC,iBAAiB,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAClD,MAAM,CAAC,iBAAiB,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAClD,MAAM,CAAC,iBAAiB,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;YACzC,gBAAgB;YAChB,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,cAAc,EAAE;oBACxC,IAAI,EAAE,SAAS;oBACf,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,YAAY;oBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YAEjB,kBAAkB;YAClB,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,gBAAgB,EAAE;oBAC1C,IAAI,EAAE,SAAS;oBACf,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,YAAY;oBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,YAAY;gBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;YAChC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,8CAAoB,CAAC,CAAC;YAC1D,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAC;YACvC,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpD,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,wCAAmB,CAAC,MAAM,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACnC,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,KAAK,GAAwB;gBACjC,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,gBAAgB,EAAE,IAAI;aACvB,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAC7C,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,eAAe;gBACrB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,gBAAgB,EAAE,IAAI;aACvB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC,WAAW,EAAE,CAAC;YAC1C,MAAM,CAAC,EAAE,CAAC,gBAAiB,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC9C,MAAM,CAAC,EAAE,CAAC,gBAAiB,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,gBAAgB,EAAE,KAAK;aACxB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;QAClC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,YAAY;gBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,QAAQ,GAAG,EAAE,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;YAErD,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YAC/B,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;QACzC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,uBAAuB,EAAE,KAAK;aAC/B,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,aAAa,EAAE,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;QAC1C,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;YAC7C,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE;oBACd,cAAc,EAAE;wBACd,SAAS,EAAE,WAAW;wBACtB,KAAK,EAAE,cAAc;wBACrB,GAAG,EAAE,WAAW;wBAChB,OAAO,EAAE,QAAQ;qBAClB;oBACD,MAAM,EAAE;wBACN,YAAY,EAAE,WAAW;qBAC1B;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,IAAI,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE;gBAC7B,QAAQ,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;aACrC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;YACvD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,WAAW,EAAE;gBAChD,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE;gBAC3C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACnC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;YACzC,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC7C,IAAI,EAAE,iBAAiB;gBACvB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAC1D,MAAM,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAChE,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAC5D,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAC5D,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,IAAI,EAAkB,CAAC;QAEvB,UAAU,CAAC,GAAG,EAAE;YACd,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,QAAQ,EAAE;gBACvC,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE;oBACd,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE;iBACtC;gBACD,SAAS,EAAE;oBACT,YAAY,EAAE,cAAc;oBAC5B,aAAa,EAAE,WAAW;iBAC3B;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,IAAI,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE;aAC9B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;YACvC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;YACnC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAChD,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAClC,mDAAmD,CACpD,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;YACrC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;YACvC,cAAc;YACd,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAChC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/C,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAK,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAEhD,iBAAiB;YACjB,EAAE,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC5B,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAK,CAAC,WAAW,CAAC,CAAC,aAAa,EAAE,CAAC;YACnD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,IAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,MAAM,QAAQ,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,UAAU,EAAE;gBACrD,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;YAC1C,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,CAAC,GAAG,EAAE;gBACV,EAAE,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC5C,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACtD,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,aAAa,EAAE,CAAC,MAAM,EAAE,yBAAyB,CAAC;aACnD,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,kBAAkB,EAAE;gBACvD,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,0BAA0B;aACxE,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,aAAa,EAAE,EAAE;aAClB,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;QACrC,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;YAE5D,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC3B,MAAM,EAAE,GAAG,IAAI,gCAAc,CAC3B,KAAK,EACL,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EACjC;oBACE,IAAI,EAAE,WAAW,OAAO,EAAE;oBAC1B,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,OAAO;oBACnB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CACF,CAAC;gBAEF,MAAM,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC5C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;YAE5D,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC3B,MAAM,EAAE,GAAG,IAAI,gCAAc,CAC3B,KAAK,EACL,UAAU,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EACrC;oBACE,IAAI,EAAE,eAAe,OAAO,EAAE;oBAC9B,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,OAAO;oBACnB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CACF,CAAC;gBAEF,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;gBACpD,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,WAAW,EAAE,CAAC;gBAC3D,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC;gBAC1D,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC;YAC5D,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,4BAA4B,EAAE,GAAG,EAAE;QAC1C,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,aAAa,EAAE;gBAClD,IAAI,EAAE,eAAe;gBACrB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE;oBACd,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE;oBACrC,SAAS,EAAE;wBACT;4BACE,GAAG,EAAE,CAAC;4BACN,YAAY,EAAE,OAAO;4BACrB,UAAU,EAAE,GAAG;4BACf,WAAW,EAAE;gCACX,kBAAkB,EAAE,aAAa;6BAClC;yBACF;wBACD;4BACE,GAAG,EAAE,CAAC;4BACN,YAAY,EAAE,OAAO;4BACrB,UAAU,EAAE,IAAI;4BAChB,WAAW,EAAE;gCACX,kBAAkB,EAAE,aAAa;6BAClC;yBACF;qBACF;iBACF;gBACD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC1D,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,SAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC1D,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,SAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBACxD,IAAI,EAAE,aAAa;gBACnB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,QAAQ,EAAE;oBACR,IAAI,EAAE,cAAc;oBACpB,sBAAsB,EAAE;wBACtB,qHAAqH,EACnH,EAAE;qBACL;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACrD,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC,WAAW,EAAE,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,SAAS,EAAE;gBAC9C,IAAI,EAAE,UAAU;gBAChB,QAAQ,EAAE,QAAQ;gBAClB,KAAK,EAAE,CAAC,GAAG,CAAC;gBACZ,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,YAAY,EAAE;gBACjD,IAAI,EAAE,aAAa;gBACnB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,kBAAkB,EAAE;oBAClB,eAAe,EAAE;wBACf,OAAO,EAAE,IAAI;wBACb,UAAU,EAAE,2CAA2C;qBACxD;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,kBAAkB,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC/C,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,eAAe,EAAE;oBACf,YAAY,EAAE;wBACZ,iBAAiB,EAAE,IAAI;wBACvB,WAAW,EAAE,IAAI;qBAClB;oBACD,YAAY,EAAE,eAAe;iBAC9B;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,eAAe,EAAE,YAAY,EAAE,iBAAiB,CAAC,CAAC,IAAI,CACpE,IAAI,CACL,CAAC;YACF,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;YACvD,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,YAAY,EAAE;oBACtC,IAAI,EAAE,SAAS;oBACf,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,iBAAiB;oBAC7B,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,YAAY,EAAE;oBACtC,IAAI,EAAE,SAAS;oBACf,QAAQ,EAAE,QAAQ;oBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAChD,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gCAAc,CAAC,KAAK,EAAE,UAAU,EAAE;oBACpC,IAAI,EAAE,WAAW;oBACjB,QAAQ,EAAE,QAAQ;oBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;oBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;oBACzD,cAAc,EAAE;wBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;qBACzC;iBACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;YAC/C,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,WAAW,EAAE;gBAChD,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpC,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC1C,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,CAAC,OAAO,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpD,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,aAAa,EAAE;gBAClD,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7C,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACjD,MAAM,CAAC,OAAO,EAAE,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACrD,MAAM,CAAC,OAAO,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBACxD,IAAI,EAAE,oBAAoB;gBAC1B,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,IAAI,EAAE;oBACJ,OAAO,EAAE,OAAO;oBAChB,MAAM,EAAE,MAAM;iBACf;aACF,CAAC,CAAC;YAEH,iDAAiD;YACjD,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YAEhE,qCAAqC;YACrC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YAEtD,6CAA6C;YAC7C,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QAC/D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACzC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,IAAI,gCAAc,CAAC,KAAK,EAAE,WAAW,EAAE;gBACrC,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;aAC5B,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;YAC/C,MAAM,gBAAiB,SAAQ,KAAK,CAAC,cAAc;gBACjD,YAAY,KAAgB,EAAE,EAAU;oBACtC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;oBAEjB,sBAAsB;oBACtB,MAAM,GAAG,GAAG,IAAI,gCAAc,CAAC,IAAI,EAAE,WAAW,EAAE;wBAChD,IAAI,EAAE,YAAY;wBAClB,QAAQ,EAAE,QAAQ;wBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;wBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;wBACzD,cAAc,EAAE;4BACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;yBAC1C;wBACD,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;qBAC1B,CAAC,CAAC;oBAEH,MAAM,GAAG,GAAG,IAAI,gCAAc,CAAC,IAAI,EAAE,aAAa,EAAE;wBAClD,IAAI,EAAE,cAAc;wBACpB,QAAQ,EAAE,QAAQ;wBAClB,UAAU,EAAE,YAAY;wBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;wBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;wBACzD,cAAc,EAAE;4BACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;yBAC1C;wBACD,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;qBAC5B,CAAC,CAAC;oBAEH,wCAAwC;oBACxC,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE;wBAC7C,KAAK,EAAE,GAAG,CAAC,EAAE;qBACd,CAAC,CAAC;oBAEH,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE;wBAC/C,KAAK,EAAE,GAAG,CAAC,EAAE;qBACd,CAAC,CAAC;gBACL,CAAC;aACF;YAED,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,gBAAgB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,MAAM,GAAG,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,KAAK,EAAE;gBAC3C,IAAI,EAAE,MAAM;gBACZ,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;iBAC1C;aACF,CAAC,CAAC;YAEH,MAAM,GAAG,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,KAAK,EAAE;gBAC3C,IAAI,EAAE,MAAM;gBACZ,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,YAAY;gBACxB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;iBAC1C;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAClD,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAElD,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACzC,EAAE,CAAC,wEAAwE,EAAE,GAAG,EAAE;YAChF,MAAM,MAAM,GAAG,gCAAc,CAAC,iBAAiB,CAC7C,iBAAiB,EACjB,cAAc,CACf,CAAC;YAEF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,WAAW,EAAE,CAAC;YAChD,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACpE,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC;gBAC9C,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE;aAC5C,CAAC,CAAC;YACH,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC;gBACjD,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAE5C,wBAAwB;YACxB,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CACnC,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YAC/B,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACnC,MAAM,CAAC,CAAC,QAAQ,EAAE,QAAgB,CAAA,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACvD,MAAM,CAAC,CAAC,QAAQ,EAAE,QAAgB,CAAA,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACtE,MAAM,CAAC,CAAC,QAAQ,EAAE,QAAgB,CAAA,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAEjE,0BAA0B;YAC1B,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CAC3C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,kBAAkB,CACrC,CAAC;YACF,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAClC,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,CAAC,CAAC,WAAW,EAAE,QAAgB,CAAA,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClE,MAAM,CAAC,CAAC,WAAW,EAAE,QAAgB,CAAA,CAAC,UAAU,CAAC,CAAC,IAAI,CACpD,wBAAwB,CACzB,CAAC;YACF,MAAM,CAAC,CAAC,WAAW,EAAE,QAAgB,CAAA,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAEjE,+BAA+B;YAC/B,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,uBAAuB,CAC1C,CAAC;YACF,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;YAChC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACpC,MAAM,CAAC,CAAC,SAAS,EAAE,QAAgB,CAAA,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxD,MAAM,CAAC,CAAC,SAAS,EAAE,QAAgB,CAAA,CAAC,UAAU,CAAC,CAAC,IAAI,CAClD,qBAAqB,CACtB,CAAC;YACF,MAAM,CAAC,CAAC,SAAS,EAAE,QAAgB,CAAA,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAElE,6BAA6B;YAC7B,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACjD,MAAM,aAAa,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC;YACpD,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACtD,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;gBAC7C;oBACE,KAAK,EAAE,eAAe;oBACtB,WAAW,EAAE,0CAA0C;iBACxD;aACF,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mGAAmG,EAAE,GAAG,EAAE;YAC3G,MAAM,MAAM,GAAG,gCAAc,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;YAEnE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClC,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,aAAa,EAAE,CAAC;YAClD,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,MAAM,GAAG,gCAAc,CAAC,iBAAiB,CAC7C,iBAAiB,EACjB,cAAc,EACd;gBACE,YAAY,EAAE,EAAE;gBAChB,eAAe,EAAE,SAAS;gBAC1B,gBAAgB,EAAE,CAAC;aACpB,CACF,CAAC;YAEF,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CACnC,CAAC;YACF,MAAM,CAAC,CAAC,QAAQ,EAAE,QAAgB,CAAA,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACvD,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAEnC,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CAC3C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,kBAAkB,CACrC,CAAC;YACF,MAAM,CAAC,CAAC,WAAW,EAAE,QAAgB,CAAA,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;YACvD,MAAM,MAAM,GAAG,gCAAc,CAAC,iBAAiB,CAC7C,iBAAiB,EACjB,cAAc,EACd;gBACE,cAAc,EAAE,KAAK;gBACrB,oBAAoB,EAAE,KAAK;gBAC3B,mBAAmB,EAAE,KAAK;aAC3B,CACF,CAAC;YAEF,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CAC3C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,kBAAkB,CACrC,CAAC;YACF,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CACnC,CAAC;YACF,MAAM,CAAC,QAAQ,CAAC,CAAC,aAAa,EAAE,CAAC;YAEjC,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,uBAAuB,CAC1C,CAAC;YACF,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,CAAC;YAElC,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,aAAa,EAAE,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gDAAgD,EAAE,GAAG,EAAE;YACxD,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,aAAa,EAAE;gBAClD,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,UAAU,EAAE,gCAAc,CAAC,iBAAiB,CAC1C,iBAAiB,EACjB,cAAc,CACf;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;YAE1C,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YAE3C,4BAA4B;YAC5B,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACxE,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAC7C,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,CAC5B,CAAC;YACF,MAAM,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;YAC3D,MAAM,EAAE,GAAG,IAAI,gCAAc,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,gBAAgB;gBACtB,QAAQ,EAAE,QAAQ;gBAClB,eAAe,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE;gBAC9C,cAAc,EAAE,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE;gBACzD,cAAc,EAAE;oBACd,iBAAiB,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC;iBACzC;gBACD,UAAU,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;aAC/B,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,gCAAc,CAAC,CAAC;YAE1C,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAE5C,sCAAsC;YACtC,MAAM,YAAY,GAAG,WAAW,CAAC,QAAQ,EAAE,cAAc;gBACvD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC9D,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC,CAC7B;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAEpC,4CAA4C;YAC5C,MAAM,kBAAkB,GAAG,WAAW,CAAC,QAAQ,EAAE,cAAc;gBAC7D,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC9D,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAC3B;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Comprehensive tests for the unified VirtualMachine implementation\n *\n * This test suite validates the unified VirtualMachine class that replaces all\n * version-specific implementations using the VersionedAzapiResource framework.\n * Tests cover automatic version resolution, explicit version pinning, schema validation,\n * property transformation, and full backward compatibility.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport { VirtualMachine, VirtualMachineProps } from \"../lib/virtual-machine\";\nimport {\n  ALL_VIRTUAL_MACHINE_VERSIONS,\n  VIRTUAL_MACHINE_TYPE,\n} from \"../lib/virtual-machine-schemas\";\n\ndescribe(\"VirtualMachine - Unified Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure Virtual Machine schemas are registered\n    try {\n      manager.registerResourceType(\n        VIRTUAL_MACHINE_TYPE,\n        ALL_VIRTUAL_MACHINE_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create virtual machine with automatic latest version resolution\", () => {\n      const props: VirtualMachineProps = {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: {\n          vmSize: \"Standard_D2s_v3\",\n        },\n        storageProfile: {\n          imageReference: {\n            publisher: \"Canonical\",\n            offer: \"UbuntuServer\",\n            sku: \"18.04-LTS\",\n            version: \"latest\",\n          },\n          osDisk: {\n            createOption: \"FromImage\",\n            managedDisk: {\n              storageAccountType: \"Premium_LRS\",\n            },\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [\n            {\n              id: \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic\",\n            },\n          ],\n        },\n      };\n\n      const vm = new VirtualMachine(stack, \"TestVM\", props);\n\n      expect(vm).toBeInstanceOf(VirtualMachine);\n      expect(vm.resolvedApiVersion).toBe(\"2025-04-01\"); // Latest version\n      expect(vm.props).toBe(props);\n      expect(vm.name).toBe(\"test-vm\");\n      expect(vm.location).toBe(\"eastus\");\n    });\n\n    it(\"should create virtual machine with explicit version pinning\", () => {\n      const props: VirtualMachineProps = {\n        name: \"test-vm-pinned\",\n        location: \"westus\",\n        apiVersion: \"2024-07-01\",\n        hardwareProfile: {\n          vmSize: \"Standard_D2s_v3\",\n        },\n        storageProfile: {\n          imageReference: {\n            publisher: \"Canonical\",\n            offer: \"UbuntuServer\",\n            sku: \"18.04-LTS\",\n            version: \"latest\",\n          },\n          osDisk: {\n            createOption: \"FromImage\",\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [\n            {\n              id: \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic\",\n            },\n          ],\n        },\n        tags: { environment: \"test\" },\n      };\n\n      const vm = new VirtualMachine(stack, \"TestVM\", props);\n\n      expect(vm.resolvedApiVersion).toBe(\"2024-07-01\");\n      expect(vm.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should create virtual machine with all optional properties\", () => {\n      const props: VirtualMachineProps = {\n        name: \"test-vm-full\",\n        location: \"centralus\",\n        hardwareProfile: {\n          vmSize: \"Standard_D4s_v3\",\n        },\n        storageProfile: {\n          imageReference: {\n            publisher: \"Canonical\",\n            offer: \"UbuntuServer\",\n            sku: \"18.04-LTS\",\n            version: \"latest\",\n          },\n          osDisk: {\n            createOption: \"FromImage\",\n            managedDisk: {\n              storageAccountType: \"Premium_LRS\",\n            },\n          },\n          dataDisks: [\n            {\n              lun: 0,\n              createOption: \"Empty\",\n              diskSizeGB: 512,\n            },\n          ],\n        },\n        osProfile: {\n          computerName: \"testvm\",\n          adminUsername: \"azureuser\",\n          linuxConfiguration: {\n            disablePasswordAuthentication: true,\n            ssh: {\n              publicKeys: [\n                {\n                  path: \"/home/azureuser/.ssh/authorized_keys\",\n                  keyData: \"ssh-rsa AAAAB3NzaC1yc2E...\",\n                },\n              ],\n            },\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [\n            {\n              id: \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic\",\n            },\n          ],\n        },\n        identity: {\n          type: \"SystemAssigned\",\n        },\n        zones: [\"1\", \"2\"],\n        priority: \"Regular\",\n        tags: {\n          environment: \"production\",\n          project: \"cdktf-constructs\",\n        },\n        diagnosticsProfile: {\n          bootDiagnostics: {\n            enabled: true,\n          },\n        },\n        ignoreChanges: [\"tags\", \"osProfile.adminPassword\"],\n        enableValidation: true,\n        enableMigrationAnalysis: true,\n      };\n\n      const vm = new VirtualMachine(stack, \"TestVM\", props);\n\n      expect(vm.props.tags).toEqual(props.tags);\n      expect(vm.props.identity).toEqual(props.identity);\n      expect(vm.props.zones).toEqual(props.zones);\n      expect(vm.props.ignoreChanges).toEqual(props.ignoreChanges);\n    });\n\n    it(\"should create Windows VM with Windows configuration\", () => {\n      const props: VirtualMachineProps = {\n        name: \"windows-vm\",\n        location: \"eastus\",\n        hardwareProfile: {\n          vmSize: \"Standard_D2s_v3\",\n        },\n        storageProfile: {\n          imageReference: {\n            publisher: \"MicrosoftWindowsServer\",\n            offer: \"WindowsServer\",\n            sku: \"2022-datacenter\",\n            version: \"latest\",\n          },\n          osDisk: {\n            createOption: \"FromImage\",\n          },\n        },\n        osProfile: {\n          computerName: \"winvm\",\n          adminUsername: \"azureuser\",\n          adminPassword: \"P@ssw0rd1234!\",\n          windowsConfiguration: {\n            provisionVMAgent: true,\n            enableAutomaticUpdates: true,\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [\n            {\n              id: \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic\",\n            },\n          ],\n        },\n        licenseType: \"Windows_Server\",\n      };\n\n      const vm = new VirtualMachine(stack, \"WindowsVM\", props);\n\n      expect(vm).toBeInstanceOf(VirtualMachine);\n      expect(vm.props.licenseType).toBe(\"Windows_Server\");\n      expect(vm.props.osProfile?.windowsConfiguration).toBeDefined();\n    });\n\n    it(\"should create Spot VM with billing profile\", () => {\n      const props: VirtualMachineProps = {\n        name: \"spot-vm\",\n        location: \"eastus\",\n        priority: \"Spot\",\n        evictionPolicy: \"Deallocate\",\n        billingProfile: {\n          maxPrice: -1,\n        },\n        hardwareProfile: {\n          vmSize: \"Standard_D2s_v3\",\n        },\n        storageProfile: {\n          osDisk: {\n            createOption: \"FromImage\",\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [\n            {\n              id: \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.Network/networkInterfaces/test-nic\",\n            },\n          ],\n        },\n      };\n\n      const vm = new VirtualMachine(stack, \"SpotVM\", props);\n\n      expect(vm.props.priority).toBe(\"Spot\");\n      expect(vm.props.evictionPolicy).toBe(\"Deallocate\");\n      expect(vm.props.billingProfile?.maxPrice).toBe(-1);\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.resolvedApiVersion).toBe(\"2025-04-01\");\n      expect(vm.latestVersion()).toBe(\"2025-04-01\");\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      const supportedVersions = vm.supportedVersions();\n      expect(supportedVersions).toContain(\"2024-07-01\");\n      expect(supportedVersions).toContain(\"2024-11-01\");\n      expect(supportedVersions).toContain(\"2024-07-01\");\n    });\n\n    it(\"should validate version support\", () => {\n      // Valid version\n      expect(() => {\n        new VirtualMachine(stack, \"ValidVersion\", {\n          name: \"test-vm\",\n          location: \"eastus\",\n          apiVersion: \"2024-11-01\",\n          hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n          storageProfile: { osDisk: { createOption: \"FromImage\" } },\n          networkProfile: {\n            networkInterfaces: [{ id: \"/test/nic\" }],\n          },\n        });\n      }).not.toThrow();\n\n      // Invalid version\n      expect(() => {\n        new VirtualMachine(stack, \"InvalidVersion\", {\n          name: \"test-vm\",\n          location: \"eastus\",\n          apiVersion: \"2026-01-01\",\n          hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n          storageProfile: { osDisk: { createOption: \"FromImage\" } },\n          networkProfile: {\n            networkInterfaces: [{ id: \"/test/nic\" }],\n          },\n        });\n      }).toThrow(\"Unsupported API version '2026-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        apiVersion: \"2024-07-01\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.schema).toBeDefined();\n      expect(vm.schema.resourceType).toBe(VIRTUAL_MACHINE_TYPE);\n      expect(vm.schema.version).toBe(\"2024-07-01\");\n      expect(vm.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.versionConfig).toBeDefined();\n      expect(vm.versionConfig.version).toBe(\"2025-04-01\");\n      expect(vm.versionConfig.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    it(\"should validate properties when validation is enabled\", () => {\n      const props: VirtualMachineProps = {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new VirtualMachine(stack, \"TestVM\", props);\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results for valid properties\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"valid-vm-name\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        enableValidation: true,\n      });\n\n      expect(vm.validationResult).toBeDefined();\n      expect(vm.validationResult!.valid).toBe(true);\n      expect(vm.validationResult!.errors).toHaveLength(0);\n    });\n\n    it(\"should skip validation when disabled\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        enableValidation: false,\n      });\n\n      expect(vm).toBeDefined();\n    });\n  });\n\n  describe(\"Migration Analysis\", () => {\n    it(\"should perform migration analysis between versions\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        apiVersion: \"2024-07-01\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      const analysis = vm.analyzeMigrationTo(\"2025-04-01\");\n\n      expect(analysis).toBeDefined();\n      expect(analysis.fromVersion).toBe(\"2024-07-01\");\n      expect(analysis.toVersion).toBe(\"2025-04-01\");\n      expect(analysis.compatible).toBe(true);\n    });\n\n    it(\"should skip migration analysis when disabled\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        enableMigrationAnalysis: false,\n      });\n\n      expect(vm.migrationAnalysis).toBeUndefined();\n    });\n  });\n\n  describe(\"Resource Creation and Body\", () => {\n    it(\"should create correct resource body\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"westus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: {\n          imageReference: {\n            publisher: \"Canonical\",\n            offer: \"UbuntuServer\",\n            sku: \"18.04-LTS\",\n            version: \"latest\",\n          },\n          osDisk: {\n            createOption: \"FromImage\",\n          },\n        },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        tags: { environment: \"test\" },\n        identity: { type: \"SystemAssigned\" },\n      });\n\n      expect(vm).toBeDefined();\n      expect(vm.props.tags).toEqual({ environment: \"test\" });\n      expect(vm.props.identity).toEqual({ type: \"SystemAssigned\" });\n    });\n\n    it(\"should handle minimal resource creation\", () => {\n      const vm = new VirtualMachine(stack, \"MinimalVM\", {\n        name: \"minimal-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_B1s\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm).toBeDefined();\n      expect(vm.name).toBe(\"minimal-vm\");\n      expect(vm.location).toBe(\"eastus\");\n      expect(vm.vmSize).toBe(\"Standard_B1s\");\n    });\n\n    it(\"should create Terraform outputs\", () => {\n      const vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm-outputs\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vm.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vm.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vm.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vm.vmIdOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n  });\n\n  describe(\"Public Methods and Properties\", () => {\n    let vm: VirtualMachine;\n\n    beforeEach(() => {\n      vm = new VirtualMachine(stack, \"TestVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: {\n          osDisk: { createOption: \"FromImage\" },\n        },\n        osProfile: {\n          computerName: \"testcomputer\",\n          adminUsername: \"azureuser\",\n        },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        tags: { environment: \"test\" },\n      });\n    });\n\n    it(\"should have correct id format\", () => {\n      expect(vm.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n    });\n\n    it(\"should have vmId property\", () => {\n      expect(vm.vmId).toMatch(/^\\$\\{.*\\.output\\.properties\\.vmId\\}$/);\n    });\n\n    it(\"should have provisioningState property\", () => {\n      expect(vm.provisioningState).toMatch(\n        /^\\$\\{.*\\.output\\.properties\\.provisioningState\\}$/,\n      );\n    });\n\n    it(\"should have computerName property\", () => {\n      expect(vm.computerName).toBe(\"testcomputer\");\n    });\n\n    it(\"should have vmSize property\", () => {\n      expect(vm.vmSize).toBe(\"Standard_D2s_v3\");\n    });\n\n    it(\"should support tag management\", () => {\n      // Test addTag\n      vm.addTag(\"newTag\", \"newValue\");\n      expect(vm.props.tags!.newTag).toBe(\"newValue\");\n      expect(vm.props.tags!.environment).toBe(\"test\");\n\n      // Test removeTag\n      vm.removeTag(\"environment\");\n      expect(vm.props.tags!.environment).toBeUndefined();\n      expect(vm.props.tags!.newTag).toBe(\"newValue\");\n    });\n\n    it(\"should add tags when no tags exist\", () => {\n      const vmNoTags = new VirtualMachine(stack, \"NoTagsVM\", {\n        name: \"no-tags-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      vmNoTags.addTag(\"firstTag\", \"firstValue\");\n      expect(vmNoTags.props.tags!.firstTag).toBe(\"firstValue\");\n    });\n\n    it(\"should handle removing non-existent tags gracefully\", () => {\n      expect(() => {\n        vm.removeTag(\"nonExistentTag\");\n      }).not.toThrow();\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const vm = new VirtualMachine(stack, \"IgnoreChangesVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        ignoreChanges: [\"tags\", \"osProfile.adminPassword\"],\n      });\n\n      expect(vm).toBeInstanceOf(VirtualMachine);\n    });\n\n    it(\"should filter out invalid ignore changes\", () => {\n      const vm = new VirtualMachine(stack, \"FilteredIgnoreVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        ignoreChanges: [\"tags\", \"name\", \"location\"], // name should be filtered\n      });\n\n      expect(vm).toBeInstanceOf(VirtualMachine);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const vm = new VirtualMachine(stack, \"EmptyIgnoreVM\", {\n        name: \"test-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        ignoreChanges: [],\n      });\n\n      expect(vm).toBeInstanceOf(VirtualMachine);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-11-01\", \"2025-04-01\"];\n\n      versions.forEach((version) => {\n        const vm = new VirtualMachine(\n          stack,\n          `VM-${version.replace(/-/g, \"\")}`,\n          {\n            name: `test-vm-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n            hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n            storageProfile: { osDisk: { createOption: \"FromImage\" } },\n            networkProfile: {\n              networkInterfaces: [{ id: \"/test/nic\" }],\n            },\n          },\n        );\n\n        expect(vm.resolvedApiVersion).toBe(version);\n        expect(vm.schema.version).toBe(version);\n      });\n    });\n\n    it(\"should handle schema differences across versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-11-01\", \"2025-04-01\"];\n\n      versions.forEach((version) => {\n        const vm = new VirtualMachine(\n          stack,\n          `Schema-${version.replace(/-/g, \"\")}`,\n          {\n            name: `schema-test-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n            hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n            storageProfile: { osDisk: { createOption: \"FromImage\" } },\n            networkProfile: {\n              networkInterfaces: [{ id: \"/test/nic\" }],\n            },\n          },\n        );\n\n        expect(vm.schema.properties.location).toBeDefined();\n        expect(vm.schema.properties.hardwareProfile).toBeDefined();\n        expect(vm.schema.properties.storageProfile).toBeDefined();\n        expect(vm.schema.properties.networkProfile).toBeDefined();\n      });\n    });\n  });\n\n  describe(\"VM Configuration Scenarios\", () => {\n    it(\"should support VM with data disks\", () => {\n      const vm = new VirtualMachine(stack, \"DataDisksVM\", {\n        name: \"data-disks-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: {\n          osDisk: { createOption: \"FromImage\" },\n          dataDisks: [\n            {\n              lun: 0,\n              createOption: \"Empty\",\n              diskSizeGB: 512,\n              managedDisk: {\n                storageAccountType: \"Premium_LRS\",\n              },\n            },\n            {\n              lun: 1,\n              createOption: \"Empty\",\n              diskSizeGB: 1024,\n              managedDisk: {\n                storageAccountType: \"Premium_LRS\",\n              },\n            },\n          ],\n        },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.props.storageProfile.dataDisks).toHaveLength(2);\n      expect(vm.props.storageProfile.dataDisks![0].lun).toBe(0);\n      expect(vm.props.storageProfile.dataDisks![1].lun).toBe(1);\n    });\n\n    it(\"should support VM with managed identity\", () => {\n      const vm = new VirtualMachine(stack, \"ManagedIdentityVM\", {\n        name: \"identity-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        identity: {\n          type: \"UserAssigned\",\n          userAssignedIdentities: {\n            \"/subscriptions/test/resourceGroups/test-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-identity\":\n              {},\n          },\n        },\n      });\n\n      expect(vm.props.identity?.type).toBe(\"UserAssigned\");\n      expect(vm.props.identity?.userAssignedIdentities).toBeDefined();\n    });\n\n    it(\"should support VM in availability zones\", () => {\n      const vm = new VirtualMachine(stack, \"ZonalVM\", {\n        name: \"zonal-vm\",\n        location: \"eastus\",\n        zones: [\"1\"],\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(vm.props.zones).toEqual([\"1\"]);\n    });\n\n    it(\"should support VM with boot diagnostics\", () => {\n      const vm = new VirtualMachine(stack, \"BootDiagVM\", {\n        name: \"bootdiag-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        diagnosticsProfile: {\n          bootDiagnostics: {\n            enabled: true,\n            storageUri: \"https://teststorage.blob.core.windows.net\",\n          },\n        },\n      });\n\n      expect(vm.props.diagnosticsProfile?.bootDiagnostics?.enabled).toBe(true);\n    });\n\n    it(\"should support VM with security profile\", () => {\n      const vm = new VirtualMachine(stack, \"SecureVM\", {\n        name: \"secure-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        securityProfile: {\n          uefiSettings: {\n            secureBootEnabled: true,\n            vTpmEnabled: true,\n          },\n          securityType: \"TrustedLaunch\",\n        },\n      });\n\n      expect(vm.props.securityProfile?.uefiSettings?.secureBootEnabled).toBe(\n        true,\n      );\n      expect(vm.props.securityProfile?.securityType).toBe(\"TrustedLaunch\");\n    });\n  });\n\n  describe(\"Error Handling\", () => {\n    it(\"should handle invalid API versions gracefully\", () => {\n      expect(() => {\n        new VirtualMachine(stack, \"InvalidAPI\", {\n          name: \"test-vm\",\n          location: \"eastus\",\n          apiVersion: \"invalid-version\",\n          hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n          storageProfile: { osDisk: { createOption: \"FromImage\" } },\n          networkProfile: {\n            networkInterfaces: [{ id: \"/test/nic\" }],\n          },\n        });\n      }).toThrow(\"Unsupported API version 'invalid-version'\");\n    });\n\n    it(\"should handle schema registration errors gracefully\", () => {\n      expect(() => {\n        new VirtualMachine(stack, \"SchemaTest\", {\n          name: \"test-vm\",\n          location: \"eastus\",\n          hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n          storageProfile: { osDisk: { createOption: \"FromImage\" } },\n          networkProfile: {\n            networkInterfaces: [{ id: \"/test/nic\" }],\n          },\n        });\n      }).not.toThrow();\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant constructor\", () => {\n      expect(() => {\n        new VirtualMachine(stack, \"JsiiTest\", {\n          name: \"jsii-test\",\n          location: \"eastus\",\n          hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n          storageProfile: { osDisk: { createOption: \"FromImage\" } },\n          networkProfile: {\n            networkInterfaces: [{ id: \"/test/nic\" }],\n          },\n        });\n      }).not.toThrow();\n    });\n\n    it(\"should have JSII-compliant properties\", () => {\n      const vm = new VirtualMachine(stack, \"JsiiProps\", {\n        name: \"jsii-props\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(typeof vm.id).toBe(\"string\");\n      expect(typeof vm.name).toBe(\"string\");\n      expect(typeof vm.location).toBe(\"string\");\n      expect(typeof vm.tags).toBe(\"object\");\n      expect(typeof vm.resolvedApiVersion).toBe(\"string\");\n      expect(typeof vm.vmId).toBe(\"string\");\n      expect(typeof vm.vmSize).toBe(\"string\");\n    });\n\n    it(\"should have JSII-compliant methods\", () => {\n      const vm = new VirtualMachine(stack, \"JsiiMethods\", {\n        name: \"jsii-methods\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n      });\n\n      expect(typeof vm.addTag).toBe(\"function\");\n      expect(typeof vm.removeTag).toBe(\"function\");\n      expect(typeof vm.latestVersion).toBe(\"function\");\n      expect(typeof vm.supportedVersions).toBe(\"function\");\n      expect(typeof vm.analyzeMigrationTo).toBe(\"function\");\n    });\n\n    it(\"should serialize complex objects correctly\", () => {\n      const vm = new VirtualMachine(stack, \"JsiiSerialization\", {\n        name: \"jsii-serialization\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        tags: {\n          complex: \"value\",\n          nested: \"data\",\n        },\n      });\n\n      // Should be able to serialize validation results\n      expect(() => JSON.stringify(vm.validationResult)).not.toThrow();\n\n      // Should be able to serialize schema\n      expect(() => JSON.stringify(vm.schema)).not.toThrow();\n\n      // Should be able to serialize version config\n      expect(() => JSON.stringify(vm.versionConfig)).not.toThrow();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new VirtualMachine(stack, \"SynthTest\", {\n        name: \"synth-test\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        tags: { test: \"synthesis\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should work in complex CDK constructs\", () => {\n      class ComplexConstruct extends cdktf.TerraformStack {\n        constructor(scope: cdktf.App, id: string) {\n          super(scope, id);\n\n          // Create multiple VMs\n          const vm1 = new VirtualMachine(this, \"PrimaryVM\", {\n            name: \"primary-vm\",\n            location: \"eastus\",\n            hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n            storageProfile: { osDisk: { createOption: \"FromImage\" } },\n            networkProfile: {\n              networkInterfaces: [{ id: \"/test/nic1\" }],\n            },\n            tags: { tier: \"primary\" },\n          });\n\n          const vm2 = new VirtualMachine(this, \"SecondaryVM\", {\n            name: \"secondary-vm\",\n            location: \"westus\",\n            apiVersion: \"2024-07-01\",\n            hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n            storageProfile: { osDisk: { createOption: \"FromImage\" } },\n            networkProfile: {\n              networkInterfaces: [{ id: \"/test/nic2\" }],\n            },\n            tags: { tier: \"secondary\" },\n          });\n\n          // Create outputs that reference the VMs\n          new cdktf.TerraformOutput(this, \"PrimaryVMId\", {\n            value: vm1.id,\n          });\n\n          new cdktf.TerraformOutput(this, \"SecondaryVMId\", {\n            value: vm2.id,\n          });\n        }\n      }\n\n      expect(() => {\n        new ComplexConstruct(app, \"ComplexStack\");\n      }).not.toThrow();\n    });\n\n    it(\"should handle multiple VMs in the same stack\", () => {\n      const vm1 = new VirtualMachine(stack, \"VM1\", {\n        name: \"vm-1\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic1\" }],\n        },\n      });\n\n      const vm2 = new VirtualMachine(stack, \"VM2\", {\n        name: \"vm-2\",\n        location: \"westus\",\n        apiVersion: \"2024-11-01\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic2\" }],\n        },\n      });\n\n      expect(vm1.resolvedApiVersion).toBe(\"2025-04-01\");\n      expect(vm2.resolvedApiVersion).toBe(\"2024-11-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"VirtualMachine Monitoring\", () => {\n    it(\"should return default monitoring configuration with all alerts enabled\", () => {\n      const config = VirtualMachine.defaultMonitoring(\n        \"action-group-id\",\n        \"workspace-id\",\n      );\n\n      expect(config.enabled).toBe(true);\n      expect(config.diagnosticSettings).toBeDefined();\n      expect(config.diagnosticSettings?.workspaceId).toBe(\"workspace-id\");\n      expect(config.diagnosticSettings?.logs).toEqual([\n        { categoryGroup: \"allLogs\", enabled: true },\n      ]);\n      expect(config.diagnosticSettings?.metrics).toEqual([\n        { category: \"AllMetrics\", enabled: true },\n      ]);\n\n      expect(config.metricAlerts).toHaveLength(3);\n\n      // Verify high-cpu-alert\n      const cpuAlert = config.metricAlerts?.find(\n        (a) => a.name === \"high-cpu-alert\",\n      );\n      expect(cpuAlert).toBeDefined();\n      expect(cpuAlert?.severity).toBe(2);\n      expect((cpuAlert?.criteria as any).threshold).toBe(80);\n      expect((cpuAlert?.criteria as any).metricName).toBe(\"Percentage CPU\");\n      expect((cpuAlert?.criteria as any).operator).toBe(\"GreaterThan\");\n\n      // Verify low-memory-alert\n      const memoryAlert = config.metricAlerts?.find(\n        (a) => a.name === \"low-memory-alert\",\n      );\n      expect(memoryAlert).toBeDefined();\n      expect(memoryAlert?.severity).toBe(2);\n      expect((memoryAlert?.criteria as any).threshold).toBe(1073741824);\n      expect((memoryAlert?.criteria as any).metricName).toBe(\n        \"Available Memory Bytes\",\n      );\n      expect((memoryAlert?.criteria as any).operator).toBe(\"LessThan\");\n\n      // Verify high-disk-queue-alert\n      const diskAlert = config.metricAlerts?.find(\n        (a) => a.name === \"high-disk-queue-alert\",\n      );\n      expect(diskAlert).toBeDefined();\n      expect(diskAlert?.severity).toBe(2);\n      expect((diskAlert?.criteria as any).threshold).toBe(32);\n      expect((diskAlert?.criteria as any).metricName).toBe(\n        \"OS Disk Queue Depth\",\n      );\n      expect((diskAlert?.criteria as any).operator).toBe(\"GreaterThan\");\n\n      // Verify activity log alerts\n      expect(config.activityLogAlerts).toHaveLength(1);\n      const deletionAlert = config.activityLogAlerts?.[0];\n      expect(deletionAlert?.name).toBe(\"vm-deletion-alert\");\n      expect(deletionAlert?.condition.allOf).toEqual([\n        {\n          field: \"operationName\",\n          equalsValue: \"Microsoft.Compute/virtualMachines/delete\",\n        },\n      ]);\n    });\n\n    it(\"should return monitoring configuration without diagnostic settings when workspace ID not provided\", () => {\n      const config = VirtualMachine.defaultMonitoring(\"action-group-id\");\n\n      expect(config.enabled).toBe(true);\n      expect(config.diagnosticSettings).toBeUndefined();\n      expect(config.metricAlerts).toHaveLength(3);\n      expect(config.activityLogAlerts).toHaveLength(1);\n    });\n\n    it(\"should customize thresholds and severities\", () => {\n      const config = VirtualMachine.defaultMonitoring(\n        \"action-group-id\",\n        \"workspace-id\",\n        {\n          cpuThreshold: 90,\n          memoryThreshold: 524288000,\n          cpuAlertSeverity: 1,\n        },\n      );\n\n      const cpuAlert = config.metricAlerts?.find(\n        (a) => a.name === \"high-cpu-alert\",\n      );\n      expect((cpuAlert?.criteria as any).threshold).toBe(90);\n      expect(cpuAlert?.severity).toBe(1);\n\n      const memoryAlert = config.metricAlerts?.find(\n        (a) => a.name === \"low-memory-alert\",\n      );\n      expect((memoryAlert?.criteria as any).threshold).toBe(524288000);\n    });\n\n    it(\"should disable specific alerts when requested\", () => {\n      const config = VirtualMachine.defaultMonitoring(\n        \"action-group-id\",\n        \"workspace-id\",\n        {\n          enableCpuAlert: false,\n          enableDiskQueueAlert: false,\n          enableDeletionAlert: false,\n        },\n      );\n\n      expect(config.metricAlerts).toHaveLength(1);\n      const memoryAlert = config.metricAlerts?.find(\n        (a) => a.name === \"low-memory-alert\",\n      );\n      expect(memoryAlert).toBeDefined();\n\n      const cpuAlert = config.metricAlerts?.find(\n        (a) => a.name === \"high-cpu-alert\",\n      );\n      expect(cpuAlert).toBeUndefined();\n\n      const diskAlert = config.metricAlerts?.find(\n        (a) => a.name === \"high-disk-queue-alert\",\n      );\n      expect(diskAlert).toBeUndefined();\n\n      expect(config.activityLogAlerts).toBeUndefined();\n    });\n\n    it(\"should create VM with monitoring configuration\", () => {\n      const vm = new VirtualMachine(stack, \"MonitoredVM\", {\n        name: \"monitored-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        monitoring: VirtualMachine.defaultMonitoring(\n          \"action-group-id\",\n          \"workspace-id\",\n        ),\n      });\n\n      expect(vm).toBeDefined();\n      expect(vm).toBeInstanceOf(VirtualMachine);\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n\n      // Verify VM resource exists\n      const azapiResources = Object.keys(stackConfig.resource.azapi_resource);\n      const vmResource = azapiResources.find((key) =>\n        key.includes(\"MonitoredVM\"),\n      );\n      expect(vmResource).toBeDefined();\n    });\n\n    it(\"should create VM without monitoring when disabled\", () => {\n      const vm = new VirtualMachine(stack, \"UnmonitoredVM\", {\n        name: \"unmonitored-vm\",\n        location: \"eastus\",\n        hardwareProfile: { vmSize: \"Standard_D2s_v3\" },\n        storageProfile: { osDisk: { createOption: \"FromImage\" } },\n        networkProfile: {\n          networkInterfaces: [{ id: \"/test/nic\" }],\n        },\n        monitoring: { enabled: false },\n      });\n\n      expect(vm).toBeDefined();\n      expect(vm).toBeInstanceOf(VirtualMachine);\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n\n      // Verify no metric alerts are created\n      const metricAlerts = stackConfig.resource?.azapi_resource\n        ? Object.keys(stackConfig.resource.azapi_resource).filter((key) =>\n            key.includes(\"metric-alert\"),\n          )\n        : [];\n      expect(metricAlerts.length).toBe(0);\n\n      // Verify no diagnostic settings are created\n      const diagnosticSettings = stackConfig.resource?.azapi_resource\n        ? Object.keys(stackConfig.resource.azapi_resource).filter((key) =>\n            key.includes(\"diagnostic\"),\n          )\n        : [];\n      expect(diagnosticSettings.length).toBe(0);\n    });\n  });\n});\n"]}