@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.0

package/lib/core-azure/lib/azapi/azapi-resource.js

@@ -27,9 +27,9 @@ const cdktf = require("cdktf");
 const constructs_1 = require("constructs");
 const data_azapi_client_config_1 = require("./providers-azapi/data-azapi-client-config");
 const resource_1 = require("./providers-azapi/resource");
-const schema_mapper_1 = require("./schema-mapper/schema-mapper");
+const resource_schema_validator_1 = require("./resource-schema-validator");
+const resource_version_manager_1 = require("./resource-version-manager");
 const api_version_manager_1 = require("../version-manager/api-version-manager");
-const version_interfaces_1 = require("../version-manager/interfaces/version-interfaces");
 /**
  * Abstract base class for version-aware Azure resource management
  *
@@ -77,6 +77,37 @@ const version_interfaces_1 = require("../version-manager/interfaces/version-inte
  * @stability stable
  */
 class AzapiResource extends constructs_1.Construct {
+    /**
+     * Static helper for child classes to register their schemas in static initializers
+     *
+     * This method should be called in a static initializer block of each child class
+     * to register all supported API versions and their schemas with the ApiVersionManager.
+     * The static block runs once when the class is first loaded, ensuring schemas are
+     * registered before any instances are created.
+     *
+     * @param resourceType - The Azure resource type (e.g., "Microsoft.Network/virtualNetworks")
+     * @param versions - Array of version configurations containing schemas
+     *
+     * @example
+     * static {
+     *   AzapiResource.registerSchemas(
+     *     "Microsoft.Network/virtualNetworks",
+     *     ALL_VIRTUAL_NETWORK_VERSIONS
+     *   );
+     * }
+     */
+    static registerSchemas(resourceType, versions) {
+        api_version_manager_1.ApiVersionManager.instance().registerResourceType(resourceType, versions);
+    }
+    /**
+     * The Azure resource ID
+     *
+     * This property is automatically derived from the underlying Terraform resource.
+     * Child classes no longer need to implement this property.
+     */
+    get id() {
+        return `\${${this.terraformResource.fqn}.id}`;
+    }
     /**
      * Creates a new AzapiResource instance
      *
@@ -95,50 +126,141 @@ class AzapiResource extends constructs_1.Construct {
         this.monitoringActionGroups = [];
         this.monitoringMetricAlerts = [];
         this.monitoringActivityLogAlerts = [];
-        // Initialize basic properties
-        this.name = props.name || this.node.id;
-        this.location = props.location || "eastus";
+        // Initialize basic properties that don't require abstract methods
+        // Use props.name if provided, otherwise fall back to construct ID
+        // This supports both explicit naming and automatic ID-based naming
+        this.name = this.resolveName(props);
+        this.location = this.resolveLocation(props);
         // Initialize the API version manager
         this._apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
-        // Step 1: Resolve the API version to use
-        this.resolvedApiVersion = this._resolveApiVersion(props.apiVersion);
-        // Step 2: Set required abstract properties for AzapiResource
+        // Initialize tags storage with empty object (will be populated in initialize())
+        this._tags = {};
+        // Note: We cannot initialize version manager here because it requires
+        // calling abstract methods (resourceType() and defaultVersion())
+        // which are not yet available in the base constructor.
+        // Version resolution is deferred to initialize() method.
+        // Step 1: Resolve the API version to use (doesn't call abstract methods yet)
+        // This is a placeholder that will be properly set in initialize()
+        this.resolvedApiVersion = props.apiVersion || "";
+        this.apiVersion = this.resolvedApiVersion;
+        // Step 2: Call initialize() to complete initialization after child class is ready
+        this.initialize(props);
+    }
+    /**
+     * Protected initialization method called after the constructor completes
+     *
+     * This method is called at the end of the constructor to perform initialization
+     * that requires calling abstract methods. Child classes can override this method
+     * if they need to extend initialization logic, but they MUST call super.initialize(props).
+     *
+     * @param props - Configuration properties for the resource
+     */
+    initialize(props) {
+        // Step 2: Set required abstract properties (now safe to call abstract methods)
         this._resourceType = this.resourceType();
+        // Step 3: Initialize the version manager and resolve the API version
+        this._versionManager = new resource_version_manager_1.ResourceVersionManager(this._resourceType, this.defaultVersion());
+        this.resolvedApiVersion = this._versionManager.resolveApiVersion(props.apiVersion);
         this.apiVersion = this.resolvedApiVersion;
-        // Step 3: Load the schema and version configuration
-        this.schema = this.apiSchema();
-        const versionConfig = this._apiVersionManager.versionConfig(this._resourceType, this.resolvedApiVersion);
+        // Step 3.5: Initialize tags from props
+        // This creates a mutable copy separate from the readonly props
+        this._tags = { ...(props.tags || {}) };
+        // Step 4: Load the schema and version configuration using the version manager
+        this.schema = this._versionManager.schemaForVersion(this.resolvedApiVersion);
+        const versionConfig = this._versionManager.versionConfig(this.resolvedApiVersion);
         if (!versionConfig) {
             throw new Error(`Version configuration not found for ${this.resourceType()}@${this.resolvedApiVersion}. ` +
                 `Please ensure the version is registered with the ApiVersionManager.`);
         }
         this.versionConfig = versionConfig;
-        // Step 4: Initialize the schema mapper
-        this._schemaMapper = schema_mapper_1.SchemaMapper.create(this.schema);
-        // Step 5: Process properties through the framework pipeline
+        // Step 5: Initialize the schema validator
+        this._schemaValidator = new resource_schema_validator_1.ResourceSchemaValidator(this.schema);
+        // Step 6: Process properties through the framework pipeline
         const processedProps = this._processProperties(props);
-        // Step 6: Perform validation if enabled
+        // Step 7: Perform validation if enabled
         if (props.enableValidation !== false) {
-            this.validationResult = this._validateProperties(processedProps);
+            this.validationResult =
+                this._schemaValidator.validateProps(processedProps);
             if (!this.validationResult.valid) {
-                throw new Error(`Property validation failed for ${this.resourceType}:\n` +
-                    this.validationResult.errors.join("\n"));
+                throw new Error(`Property validation failed for ${this.resourceType()}:\n` +
+                    this._schemaValidator
+                        .formatValidationErrors(this.validationResult)
+                        .join("\n"));
             }
         }
-        // Step 7: Perform migration analysis if enabled
+        // Step 8: Perform migration analysis if enabled
         if (props.enableMigrationAnalysis !== false) {
             this.migrationAnalysis = this._performMigrationAnalysis();
         }
-        // Step 8: Create the Azure resource
+        // Step 9: Create the Azure resource
         this._createAzureResource(processedProps);
-        // Step 9: Create monitoring resources if configured
+        // Step 10: Create monitoring resources if configured
         // Note: Monitoring resources are created lazily to avoid circular dependencies
         if (props.monitoring) {
             void this.createMonitoringResources(props.monitoring);
         }
-        // Step 10: Log warnings and migration guidance
+        // Step 11: Log warnings and migration guidance
         this._logFrameworkMessages();
     }
+    /**
+     * Override in child classes to provide default location
+     * @returns Default location or undefined
+     */
+    defaultLocation() {
+        return undefined;
+    }
+    /**
+     * Override in child classes to indicate if location is required
+     * @returns true if location is mandatory for this resource type
+     */
+    requiresLocation() {
+        return false;
+    }
+    /**
+     * Override in child classes to specify parent resource for location inheritance
+     * @returns Parent resource or undefined
+     */
+    parentResourceForLocation() {
+        return undefined;
+    }
+    /**
+     * Resolves location using template method pattern
+     * Priority: props.location > parent location > default location > validation
+     */
+    resolveLocation(props) {
+        // 1. Explicit location in props
+        if (props.location) {
+            return props.location;
+        }
+        // 2. Inherit from parent resource
+        const parent = this.parentResourceForLocation();
+        if (parent && parent.location) {
+            return parent.location;
+        }
+        // 3. Use child class default
+        const defaultLoc = this.defaultLocation();
+        if (defaultLoc) {
+            return defaultLoc;
+        }
+        // 4. Validate if required
+        if (this.requiresLocation()) {
+            throw new Error(`Location is required for ${this.resourceType()} but was not provided ` +
+                `and could not be inherited from parent resource.`);
+        }
+        return undefined;
+    }
+    /**
+     * Resolves the name for this resource
+     *
+     * This method centralizes name resolution logic. By default, it uses the
+     * provided name or falls back to the construct ID.
+     *
+     * @param props - The resource properties
+     * @returns The resolved resource name
+     */
+    resolveName(props) {
+        return props.name || this.node.id;
+    }
     /**
      * Helper method for standard schema resolution
      *
@@ -166,7 +288,9 @@ class AzapiResource extends constructs_1.Construct {
      * @returns The latest available version, or undefined if none found
      */
     latestVersion() {
-        return this._apiVersionManager.latestVersion(this.resourceType());
+        return this._versionManager
+            ? this._versionManager.latestVersion()
+            : this._apiVersionManager.latestVersion(this.resourceType());
     }
     /**
      * Gets all supported versions for this resource type
@@ -177,7 +301,9 @@ class AzapiResource extends constructs_1.Construct {
      * @returns Array of supported version strings, sorted by release date
      */
     supportedVersions() {
-        return this._apiVersionManager.supportedVersions(this.resourceType());
+        return this._versionManager
+            ? this._versionManager.supportedVersions()
+            : this._apiVersionManager.supportedVersions(this.resourceType());
     }
     /**
      * Analyzes migration from current version to a target version
@@ -194,39 +320,18 @@ class AzapiResource extends constructs_1.Construct {
     // =============================================================================
     // PRIVATE IMPLEMENTATION METHODS
     // =============================================================================
-    /**
-     * Resolves the API version to use for this resource instance
-     */
-    _resolveApiVersion(explicitVersion) {
-        if (explicitVersion) {
-            // Validate that the explicit version is supported
-            if (!this._apiVersionManager.validateVersionSupport(this.resourceType(), explicitVersion)) {
-                const supportedVersions = this._apiVersionManager.supportedVersions(this.resourceType());
-                throw new Error(`Unsupported API version '${explicitVersion}' for resource type '${this.resourceType()}'. ` +
-                    `Supported versions: ${supportedVersions.join(", ")}`);
-            }
-            return explicitVersion;
-        }
-        // Try to get the latest version from the manager
-        const latestVersion = this._apiVersionManager.latestVersion(this.resourceType());
-        if (latestVersion) {
-            return latestVersion;
-        }
-        // Fall back to the default version
-        const defaultVersion = this.defaultVersion();
-        // Warn that we're using the default version
-        console.warn(`No versions registered for ${this.resourceType()}. ` +
-            `Using default version: ${defaultVersion}. ` +
-            `Consider registering versions with ApiVersionManager for better version management.`);
-        return defaultVersion;
-    }
     /**
      * Processes properties through the framework pipeline
      */
     _processProperties(props) {
         let processedProps = { ...props };
-        // Apply default values from the schema
-        processedProps = this._schemaMapper.applyDefaults(processedProps);
+        // Ensure name is set before processing
+        // This is critical for validation to work correctly
+        if (!processedProps.name) {
+            processedProps.name = this.resolveName(props);
+        }
+        // Apply default values from the schema using the validator
+        processedProps = this._schemaValidator.applyDefaults(processedProps);
         // Apply property transformations if enabled
         if (props.enableTransformation !== false) {
             // For transformation, we would need a source schema, but since we're not
@@ -235,20 +340,13 @@ class AzapiResource extends constructs_1.Construct {
         }
         return processedProps;
     }
-    /**
-     * Validates properties against the schema
-     */
-    _validateProperties(props) {
-        return this._schemaMapper.validateProperties(props);
-    }
     /**
      * Performs migration analysis for the current version
      */
     _performMigrationAnalysis() {
-        // Check if the current version is deprecated
-        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED ||
-            this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET) {
-            const latestVersion = this.latestVersion();
+        // Check if the current version is deprecated using the version manager
+        if (this._versionManager.isDeprecated(this.resolvedApiVersion)) {
+            const latestVersion = this._versionManager.latestVersion();
             if (latestVersion && latestVersion !== this.resolvedApiVersion) {
                 return this._apiVersionManager.analyzeMigration(this.resourceType(), this.resolvedApiVersion, latestVersion);
             }
@@ -259,12 +357,74 @@ class AzapiResource extends constructs_1.Construct {
      * Creates the underlying Azure resource
      */
     _createAzureResource(props) {
+        // Ensure name is set in props for validation
+        const propsWithName = {
+            ...props,
+            name: props.name || this.resolveName(props),
+        };
         // Create the resource body using the subclass implementation
-        const resourceBody = this.createResourceBody(props);
+        const resourceBody = this.createResourceBody(propsWithName);
         // Determine the parent ID using the overrideable method
-        const parentId = this.resolveParentId(props);
+        const parentId = this.resolveParentId(propsWithName);
+        // Find parent AzapiResource construct if parent ID references a resource
+        const parentResource = this._findParentAzapiResource(parentId);
         // Create the AZAPI resource using the base class method
-        this.terraformResource = this.createAzapiResource(resourceBody, parentId, this.name, this.location);
+        const resourceName = this.resolveName(props);
+        this.terraformResource = this.createAzapiResource(resourceBody, parentId, resourceName, this.location, parentResource, propsWithName.dependsOn, this._tags);
+    }
+    /**
+     * Finds the parent AzapiResource construct if the parentId references a resource
+     * Returns undefined if parentId is a static string or parent not found
+     * @private
+     */
+    _findParentAzapiResource(parentId) {
+        // Check if the parent is a string interpolation referencing another resource
+        // Pattern: ${azapi_resource.resource_name_HASH.id} or ${construct.fqn}.id
+        if (!parentId.includes("${")) {
+            return undefined; // Parent is a static string ID, not a resource reference
+        }
+        // Try to find the parent AzapiResource in the construct tree
+        // We need to search the entire tree to find the matching parent
+        const root = this._findRoot();
+        return this._findParentResource(root, parentId);
+    }
+    /**
+     * Finds the root of the construct tree
+     * @private
+     */
+    _findRoot() {
+        let current = this;
+        while (current.node.scope) {
+            current = current.node.scope;
+        }
+        return current;
+    }
+    /**
+     * Recursively searches for a parent resource by matching parentId patterns
+     * Enhanced to better handle Terraform interpolation syntax
+     * @private
+     */
+    _findParentResource(scope, parentId) {
+        // Check all children of this scope
+        for (const child of scope.node.children) {
+            if (child instanceof AzapiResource &&
+                child !== this &&
+                child.terraformResource) {
+                const childFqn = child.terraformResource.fqn;
+                // Match if the child's FQN appears anywhere in the parentId string
+                // This handles cases like: ${azapi_resource.dns-resolver_resource_F1517BE4.id}
+                // where childFqn would be: azapi_resource.dns-resolver_resource_F1517BE4
+                if (parentId.includes(childFqn)) {
+                    return child;
+                }
+            }
+            // Recursively search in child's subtree
+            const found = this._findParentResource(child, parentId);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
     }
     /**
      * Resolves the parent resource ID for this resource.
@@ -282,23 +442,19 @@ class AzapiResource extends constructs_1.Construct {
     /**
      * Determines the parent ID for the resource (internal implementation)
      *
-     * This method provides the default parent ID resolution logic for most resources.
-     * Child resources should override resolveParentId() instead of this method.
+     * This method provides the default parent ID resolution logic.
+     * Resource-specific logic should be implemented in the overrideable resolveParentId() method.
+     *
+     * Default behavior:
+     * - If resourceGroupId is provided in props, use it
+     * - Otherwise, default to subscription scope
      */
     _determineParentId(props) {
-        // This is a simplified implementation - real implementation would be
-        // resource-type specific and could be made abstract or configurable
-        // For resource groups, parent is subscription
-        if (this.resourceType() === "Microsoft.Resources/resourceGroups") {
-            // Use AZAPI client config to get subscription ID
-            const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "client_config", {});
-            return `/subscriptions/\${${clientConfig.fqn}.subscription_id}`;
-        }
-        // For other resources, parent might be resource group
+        // If resource group ID is provided, use it as parent
         if (props.resourceGroupId) {
             return props.resourceGroupId;
         }
-        // Default to subscription
+        // Default to subscription scope for resources without explicit parent
         const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "client_config_default", {});
         return `/subscriptions/\${${clientConfig.fqn}.subscription_id}`;
     }
@@ -311,12 +467,13 @@ class AzapiResource extends constructs_1.Construct {
         const YELLOW = "\x1b[33m";
         const RESET = "\x1b[0m";
         const BOLD = "\x1b[1m";
-        // Log deprecation warnings
-        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED) {
+        // Log deprecation warnings using the version manager
+        if (this._versionManager.isDeprecated(this.resolvedApiVersion) &&
+            !this._versionManager.isSunset(this.resolvedApiVersion)) {
             console.warn(`${YELLOW}⚠️  API version ${this.resolvedApiVersion} for ${this.resourceType()} is deprecated. ` +
                 `Consider upgrading to the latest version: ${this.latestVersion()}${RESET}`);
         }
-        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET) {
+        if (this._versionManager.isSunset(this.resolvedApiVersion)) {
             console.error(`${RED}${BOLD}🚨 API version ${this.resolvedApiVersion} for ${this.resourceType()} has reached sunset. ` +
                 `Immediate migration to ${this.latestVersion()} is required.${RESET}`);
         }
@@ -400,23 +557,57 @@ class AzapiResource extends constructs_1.Construct {
     /**
      * Creates the underlying AZAPI Terraform resource using the generated provider classes
      *
-     * @param properties - The properties object to send to the Azure API
+     * @param properties - The properties object to send to the Azure API (should include location if needed)
      * @param parentId - The parent resource ID (e.g., subscription or resource group)
      * @param name - The name of the resource
-     * @param location - The location of the resource (optional, can be in properties)
+     * @param location - The location of the resource (optional, only for top-level resources without location in body)
+     * @param parentResource - The parent resource for dependency tracking
+     * @param dependsOn - Explicit dependencies for this resource
+     * @param tags - Tags to apply to the resource (passed separately from body for proper idempotency)
      * @returns The created AZAPI resource
      */
-    createAzapiResource(properties, parentId, name, location) {
+    createAzapiResource(properties, parentId, name, location, parentResource, dependsOn, tags) {
+        // Determine if this is a child resource by counting path segments
+        // Child resources have multiple segments (e.g., "Microsoft.Network/virtualNetworks/subnets")
+        // Top-level resources have one segment (e.g., "Microsoft.Network/virtualNetworks")
+        const resourceTypeParts = this._resourceType.split("/");
+        const isChildResource = resourceTypeParts.length > 2;
+        // Remove tags from properties to avoid duplicate specification error
+        // The AZAPI provider requires tags at the top level only, not in the body
+        // This prevents: "can't specify both the argument 'tags' and 'tags' in the argument 'body'"
+        // Tags are now passed as a separate parameter for better clarity and idempotency
+        const bodyWithoutTags = { ...properties };
+        delete bodyWithoutTags.tags;
         // Build the configuration object for the generated AZAPI Resource class
+        // Add location only if:
+        // 1. This is a top-level resource (not a child resource)
+        // 2. Location is provided as parameter
+        // 3. Location is not already in the body
+        // Child resources inherit location from their parent and should not specify it
+        // Combine dependsOn arrays: explicit dependencies + parent resource dependency
+        const combinedDependsOn = [];
+        if (dependsOn && dependsOn.length > 0) {
+            combinedDependsOn.push(...dependsOn);
+        }
+        // CRITICAL: Always add parent dependency when parent_id contains interpolations
+        // This ensures proper destroy-time ordering even if parent detection fails
+        if (parentResource?.terraformResource) {
+            combinedDependsOn.push(parentResource.terraformResource);
+        }
         const config = {
             type: `${this._resourceType}@${this.apiVersion}`,
             name: name,
             parentId: parentId,
-            body: properties,
-            // Add location conditionally if provided and not already in properties
-            ...(location && !properties.location && { location: location }),
+            body: bodyWithoutTags,
+            ...(!isChildResource && location && !properties.location && { location }),
+            // Add tags at the top level if they exist
+            // Tags are passed as a separate parameter and added here to ensure they're in the
+            // initial Terraform configuration, providing proper idempotency
+            ...(tags && Object.keys(tags).length > 0 && { tags }),
+            // Add depends_on for explicit dependencies and parent resource
+            ...(combinedDependsOn.length > 0 && { dependsOn: combinedDependsOn }),
         };
-        // Create and return the AZAPI resource using the generated provider class
+        // Create the AZAPI resource using the generated provider class
         return new resource_1.Resource(this, "resource", config);
     }
     /**
@@ -452,6 +643,13 @@ class AzapiResource extends constructs_1.Construct {
     get resourceId() {
         return this.terraformResource?.fqn || this.id;
     }
+    /**
+     * Gets the underlying Terraform resource for use in dependency declarations
+     * This allows explicit dependency management between resources
+     */
+    get resource() {
+        return this.terraformResource;
+    }
     /**
      * Gets the resource as a Terraform output value
      */
@@ -475,10 +673,50 @@ class AzapiResource extends constructs_1.Construct {
             scope: this.resourceId,
         });
     }
+    /**
+     * Adds a tag to this resource. The tag will be included in the Azure resource.
+     *
+     * This method provides proper immutability by storing tags separately from props.
+     * Tags added via this method are combined with tags from props and included in
+     * the deployed Azure resource.
+     *
+     * **Important:** In CDK for Terraform, tags should ideally be set during resource
+     * construction via props. While this method allows adding tags after construction,
+     * those tags are only included if added before the Terraform configuration is
+     * synthesized. For best results, add all tags via props or call addTag() in the
+     * same scope where the resource is created.
+     *
+     * @param key - The tag key
+     * @param value - The tag value
+     */
+    addTag(key, value) {
+        this._tags[key] = value;
+    }
+    /**
+     * All tags on this resource (readonly view)
+     *
+     * This getter provides convenient access to all tags including those from props
+     * and those added dynamically via addTag(). Returns a copy to maintain immutability.
+     */
+    get tags() {
+        return { ...this._tags };
+    }
+    /**
+     * Protected method to retrieve all tags for use in createResourceBody implementations
+     *
+     * Subclasses should use this method when creating resource bodies to ensure
+     * all tags (from props and addTag()) are included in the Azure resource.
+     * Uses a non-getter name to avoid JSII conflicts with the tags property.
+     *
+     * @returns Object containing all tags
+     */
+    allTags() {
+        return { ...this._tags };
+    }
 }
 exports.AzapiResource = AzapiResource;
 _a = JSII_RTTI_SYMBOL_1;
-AzapiResource[_a] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiResource", version: "1.2.0" };
+AzapiResource[_a] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiResource", version: "1.3.0" };
 /**
  * AZAPI-based role assignment construct
  */
@@ -501,5 +739,5 @@ class AzapiRoleAssignment extends constructs_1.Construct {
 }
 exports.AzapiRoleAssignment = AzapiRoleAssignment;
 _b = JSII_RTTI_SYMBOL_1;
-AzapiRoleAssignment[_b] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiRoleAssignment", version: "1.2.0" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azapi-resource.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/azapi-resource.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AzapiResource - A unified framework for version-aware Azure resource management\n *\n * This abstract base class provides a self-contained unified framework approach\n * for Azure resource management with automatic version management, schema-driven\n * property transformation, and migration analysis capabilities.\n *\n * Key Features:\n * - Automatic latest version resolution when no version is specified\n * - Support for explicit version pinning for stability\n * - Schema-driven property transformation between versions\n * - Migration analysis and deprecation warnings\n * - Built-in role assignment and diagnostic settings support\n * - JSII-compliant design for multi-language support\n *\n * This class replaces the previous dual-class approach (AzapiResource + AzapiResource)\n * with a single, self-contained implementation that handles all resource management needs.\n *\n * @packageDocumentation\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { DataAzapiClientConfig } from \"./providers-azapi/data-azapi-client-config\";\nimport { Resource, ResourceConfig } from \"./providers-azapi/resource\";\nimport { SchemaMapper } from \"./schema-mapper/schema-mapper\";\n\n// Type-only imports to avoid circular dependencies\nimport type { ActionGroupProps } from \"../../../azure-actiongroup/lib/action-group\";\nimport type { ActivityLogAlertProps } from \"../../../azure-activitylogalert/lib/activity-log-alert\";\nimport type { DiagnosticSettingsProps } from \"../../../azure-diagnosticsettings/lib/diagnostic-settings\";\nimport type { MetricAlertProps } from \"../../../azure-metricalert/lib/metric-alert\";\nimport { ApiVersionManager } from \"../version-manager/api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  ValidationResult,\n  MigrationAnalysis,\n  VersionSupportLevel,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n/**\n * Retention policy configuration\n */\nexport interface RetentionPolicyConfig {\n  readonly enabled: boolean;\n  readonly days: number;\n}\n\n/**\n * Log configuration for diagnostic settings\n */\nexport interface DiagnosticLogConfig {\n  readonly category?: string;\n  readonly categoryGroup?: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Metric configuration for diagnostic settings\n */\nexport interface DiagnosticMetricConfig {\n  /** Metric category name (used in newer API versions) */\n  readonly category?: string;\n  /** Time grain for metrics in ISO 8601 duration format (used in API version 2016-09-01, e.g., \"PT1M\") */\n  readonly timeGrain?: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Monitoring configuration for Azure resources\n *\n * Provides integrated monitoring capabilities including diagnostic settings,\n * metric alerts, and activity log alerts. All monitoring is optional and\n * disabled by default.\n */\nexport interface MonitoringConfig {\n  /**\n   * Whether monitoring is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Diagnostic settings configuration\n   * Uses the full DiagnosticSettings construct for consistency\n   */\n  readonly diagnosticSettings?: DiagnosticSettingsProps;\n\n  /**\n   * Action groups to create for this resource\n   * Creates new ActionGroup instances as child constructs\n   */\n  readonly actionGroups?: ActionGroupProps[];\n\n  /**\n   * Metric alerts configuration\n   * Creates MetricAlert instances scoped to this resource\n   */\n  readonly metricAlerts?: MetricAlertProps[];\n\n  /**\n   * Activity log alerts configuration\n   * Creates ActivityLogAlert instances for this resource's operations\n   */\n  readonly activityLogAlerts?: ActivityLogAlertProps[];\n}\n\n/**\n * Properties for versioned Azure resources\n *\n * Combines base resource properties with version management capabilities\n * and advanced configuration options for the unified framework.\n */\nexport interface AzapiResourceProps {\n  /**\n   * The name of the resource\n   */\n  readonly name?: string;\n\n  /**\n   * The location where the resource should be created\n   */\n  readonly location?: string;\n\n  /**\n   * Tags to apply to the resource\n   */\n  readonly tags?: Record<string, string>;\n  /**\n   * Explicit API version to use for this resource\n   *\n   * If not specified, the latest active version will be automatically resolved.\n   * Use this for version pinning when stability is required over latest features.\n   *\n   * @example \"2024-11-01\"\n   * @defaultValue Latest active version from ApiVersionManager\n   */\n  readonly apiVersion?: string;\n\n  /**\n   * Whether to enable migration analysis warnings\n   *\n   * When true, the framework will analyze the current version for deprecation\n   * status and provide migration recommendations in the deployment output.\n   *\n   * @defaultValue true\n   */\n  readonly enableMigrationAnalysis?: boolean;\n\n  /**\n   * Whether to validate properties against the schema\n   *\n   * When true, all properties will be validated against the API schema before\n   * resource creation. Validation errors will cause deployment failures.\n   *\n   * @defaultValue true\n   */\n  readonly enableValidation?: boolean;\n\n  /**\n   * Whether to apply property transformations automatically\n   *\n   * When true, properties will be automatically transformed according to the\n   * target schema's transformation rules. This enables backward compatibility.\n   *\n   * @defaultValue true\n   */\n  readonly enableTransformation?: boolean;\n\n  /**\n   * Monitoring configuration for this resource\n   *\n   * Enables integrated monitoring with diagnostic settings, metric alerts,\n   * and activity log alerts. All monitoring is optional and disabled by default.\n   *\n   * @example\n   * monitoring: {\n   *   enabled: true,\n   *   diagnosticSettings: {\n   *     workspaceId: logAnalytics.id,\n   *     metrics: ['AllMetrics'],\n   *     logs: ['AuditLogs']\n   *   },\n   *   metricAlerts: [{\n   *     name: 'high-cpu-alert',\n   *     severity: 2,\n   *     scopes: [], // Automatically set to this resource\n   *     criteria: { ... },\n   *     actions: [{ actionGroupId: actionGroup.id }]\n   *   }]\n   * }\n   */\n  readonly monitoring?: MonitoringConfig;\n}\n\n/**\n * Abstract base class for version-aware Azure resource management\n *\n * AzapiResource provides a unified framework for creating Azure resources\n * with automatic version management, schema validation, property transformation,\n * and migration analysis. It extends the existing AzapiResource class while\n * maintaining full backward compatibility.\n *\n * This class implements the core framework that enables:\n * - Automatic resolution of the latest API version when none is specified\n * - Explicit version pinning for environments requiring stability\n * - Schema-driven property validation and transformation\n * - Migration analysis with breaking change detection\n * - Deprecation warnings and upgrade recommendations\n *\n * Subclasses must implement the abstract methods to provide resource-specific\n * configuration while the framework handles all version management complexity.\n *\n * @example Basic usage with automatic version resolution:\n * class MyResource extends AzapiResource {\n *   protected getDefaultVersion(): string {\n *     return \"2024-11-01\"; // fallback if no versions registered\n *   }\n *\n *   protected getResourceType(): string {\n *     return \"Microsoft.Resources/resourceGroups\";\n *   }\n *\n *   protected getApiSchema(): ApiSchema {\n *     return this.resolveSchema();\n *   }\n *\n *   protected createResourceBody(props: any): any {\n *     return { location: props.location, tags: props.tags || {} };\n *   }\n * }\n *\n * @example Usage with explicit version pinning:\n * new MyResource(this, \"resource\", {\n *   name: \"my-resource\",\n *   location: \"eastus\",\n *   apiVersion: \"2024-01-01\" // Pin to specific version\n * });\n *\n * @stability stable\n */\nexport abstract class AzapiResource extends Construct {\n  /**\n   * The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   * @internal\n   */\n  protected readonly _resourceType: string;\n\n  /**\n   * The API version to use for this resource\n   */\n  protected readonly apiVersion: string;\n\n  /**\n   * The underlying AZAPI Terraform resource\n   */\n  protected terraformResource!: cdktf.TerraformResource;\n\n  /**\n   * The name of the resource\n   */\n  public readonly name: string;\n\n  /**\n   * The location of the resource\n   */\n  public readonly location: string;\n\n  /**\n   * The resource ID (abstract - must be implemented by subclasses)\n   */\n  public abstract readonly id: string;\n\n  /**\n   * The resolved API version being used for this resource instance\n   *\n   * This is the actual version that will be used for the Azure API call,\n   * either explicitly specified in props or automatically resolved to\n   * the latest active version.\n   */\n  public readonly resolvedApiVersion: string;\n\n  /**\n   * The API schema for the resolved version\n   *\n   * Contains the complete schema definition including properties, validation\n   * rules, and transformation mappings for the resolved API version.\n   */\n  public readonly schema: ApiSchema;\n\n  /**\n   * The version configuration for the resolved version\n   *\n   * Contains lifecycle information, breaking changes, and migration metadata\n   * for the resolved API version.\n   */\n  public readonly versionConfig: VersionConfig;\n\n  /**\n   * Validation results for the resource properties\n   *\n   * Available after construction if validation is enabled. Contains detailed\n   * information about any validation errors or warnings.\n   */\n  public readonly validationResult?: ValidationResult;\n\n  /**\n   * Migration analysis results\n   *\n   * Available after construction if migration analysis is enabled and a\n   * previous version can be determined for comparison.\n   */\n  public readonly migrationAnalysis?: MigrationAnalysis;\n\n  // Framework components\n  private readonly _apiVersionManager: ApiVersionManager;\n  private readonly _schemaMapper: SchemaMapper;\n\n  // Monitoring resources (protected for subclass access)\n  protected readonly monitoringActionGroups: Construct[] = [];\n  protected readonly monitoringMetricAlerts: Construct[] = [];\n  protected readonly monitoringActivityLogAlerts: Construct[] = [];\n\n  /**\n   * Creates a new AzapiResource instance\n   *\n   * The constructor handles all framework initialization including version resolution,\n   * schema loading, property validation, transformation, and migration analysis.\n   * It maintains full backward compatibility with the AzapiResource constructor.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the resource\n   */\n  constructor(scope: Construct, id: string, props: AzapiResourceProps = {}) {\n    // Initialize the base Construct\n    super(scope, id);\n\n    // Initialize basic properties\n    this.name = props.name || this.node.id;\n    this.location = props.location || \"eastus\";\n\n    // Initialize the API version manager\n    this._apiVersionManager = ApiVersionManager.instance();\n\n    // Step 1: Resolve the API version to use\n    this.resolvedApiVersion = this._resolveApiVersion(props.apiVersion);\n\n    // Step 2: Set required abstract properties for AzapiResource\n    this._resourceType = this.resourceType();\n    this.apiVersion = this.resolvedApiVersion;\n\n    // Step 3: Load the schema and version configuration\n    this.schema = this.apiSchema();\n    const versionConfig = this._apiVersionManager.versionConfig(\n      this._resourceType,\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Version configuration not found for ${this.resourceType()}@${this.resolvedApiVersion}. ` +\n          `Please ensure the version is registered with the ApiVersionManager.`,\n      );\n    }\n    this.versionConfig = versionConfig;\n\n    // Step 4: Initialize the schema mapper\n    this._schemaMapper = SchemaMapper.create(this.schema);\n\n    // Step 5: Process properties through the framework pipeline\n    const processedProps = this._processProperties(props);\n\n    // Step 6: Perform validation if enabled\n    if (props.enableValidation !== false) {\n      this.validationResult = this._validateProperties(processedProps);\n      if (!this.validationResult.valid) {\n        throw new Error(\n          `Property validation failed for ${this.resourceType}:\\n` +\n            this.validationResult.errors.join(\"\\n\"),\n        );\n      }\n    }\n\n    // Step 7: Perform migration analysis if enabled\n    if (props.enableMigrationAnalysis !== false) {\n      this.migrationAnalysis = this._performMigrationAnalysis();\n    }\n\n    // Step 8: Create the Azure resource\n    this._createAzureResource(processedProps);\n\n    // Step 9: Create monitoring resources if configured\n    // Note: Monitoring resources are created lazily to avoid circular dependencies\n    if (props.monitoring) {\n      void this.createMonitoringResources(props.monitoring);\n    }\n\n    // Step 10: Log warnings and migration guidance\n    this._logFrameworkMessages();\n  }\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   *\n   * This method should return a sensible default version that can be used\n   * as a fallback if the ApiVersionManager doesn't have any versions registered\n   * for this resource type.\n   *\n   * @returns The default API version string (e.g., \"2024-11-01\")\n   */\n  protected abstract defaultVersion(): string;\n\n  /**\n   * Gets the Azure resource type for this resource\n   *\n   * This method should return the full Azure resource type identifier that\n   * will be used for API calls and version management.\n   *\n   * @returns The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   */\n  protected abstract resourceType(): string;\n\n  /**\n   * Gets the API schema for the resolved version\n   *\n   * This method should return the complete API schema for the resolved version,\n   * including all property definitions, validation rules, and transformation\n   * mappings. Use the resolveSchema() helper method for standard schema resolution.\n   *\n   * @returns The API schema for the resolved version\n   */\n  protected abstract apiSchema(): ApiSchema;\n\n  /**\n   * Creates the resource body for the Azure API call\n   *\n   * This method should transform the input properties into the JSON body format\n   * expected by the Azure REST API for the resolved version. The framework will\n   * have already applied any necessary property transformations and validation.\n   *\n   * @param props - The processed and validated properties for the resource\n   * @returns The resource body object to send to Azure API\n   */\n  protected abstract createResourceBody(props: any): any;\n\n  /**\n   * Helper method for standard schema resolution\n   *\n   * Subclasses can use this method to resolve the schema for the current version\n   * from the ApiVersionManager. This provides a standard implementation that\n   * most resources can use without custom logic.\n   *\n   * @returns The API schema for the resolved version\n   * @throws Error if the schema cannot be resolved\n   */\n  protected resolveSchema(): ApiSchema {\n    const versionConfig = this._apiVersionManager.versionConfig(\n      this.resourceType(),\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Cannot resolve schema: version configuration not found for ` +\n          `${this.resourceType()}@${this.resolvedApiVersion}`,\n      );\n    }\n\n    return versionConfig.schema;\n  }\n\n  /**\n   * Gets the latest available version for this resource type\n   *\n   * This method provides access to the latest version resolution logic\n   * for use in subclasses or external tooling.\n   *\n   * @returns The latest available version, or undefined if none found\n   */\n  public latestVersion(): string | undefined {\n    return this._apiVersionManager.latestVersion(this.resourceType());\n  }\n\n  /**\n   * Gets all supported versions for this resource type\n   *\n   * This method provides access to the version registry for use in\n   * subclasses or external tooling.\n   *\n   * @returns Array of supported version strings, sorted by release date\n   */\n  public supportedVersions(): string[] {\n    return this._apiVersionManager.supportedVersions(this.resourceType());\n  }\n\n  /**\n   * Analyzes migration from current version to a target version\n   *\n   * This method enables external tools to analyze migration requirements\n   * between versions for planning and automation purposes.\n   *\n   * @param targetVersion - The target version to analyze migration to\n   * @returns Detailed migration analysis results\n   */\n  public analyzeMigrationTo(targetVersion: string): MigrationAnalysis {\n    return this._apiVersionManager.analyzeMigration(\n      this.resourceType(),\n      this.resolvedApiVersion,\n      targetVersion,\n    );\n  }\n\n  // =============================================================================\n  // PRIVATE IMPLEMENTATION METHODS\n  // =============================================================================\n\n  /**\n   * Resolves the API version to use for this resource instance\n   */\n  private _resolveApiVersion(explicitVersion?: string): string {\n    if (explicitVersion) {\n      // Validate that the explicit version is supported\n      if (\n        !this._apiVersionManager.validateVersionSupport(\n          this.resourceType(),\n          explicitVersion,\n        )\n      ) {\n        const supportedVersions = this._apiVersionManager.supportedVersions(\n          this.resourceType(),\n        );\n        throw new Error(\n          `Unsupported API version '${explicitVersion}' for resource type '${this.resourceType()}'. ` +\n            `Supported versions: ${supportedVersions.join(\", \")}`,\n        );\n      }\n      return explicitVersion;\n    }\n\n    // Try to get the latest version from the manager\n    const latestVersion = this._apiVersionManager.latestVersion(\n      this.resourceType(),\n    );\n    if (latestVersion) {\n      return latestVersion;\n    }\n\n    // Fall back to the default version\n    const defaultVersion = this.defaultVersion();\n\n    // Warn that we're using the default version\n    console.warn(\n      `No versions registered for ${this.resourceType()}. ` +\n        `Using default version: ${defaultVersion}. ` +\n        `Consider registering versions with ApiVersionManager for better version management.`,\n    );\n\n    return defaultVersion;\n  }\n\n  /**\n   * Processes properties through the framework pipeline\n   */\n  private _processProperties(props: AzapiResourceProps): any {\n    let processedProps = { ...props };\n\n    // Apply default values from the schema\n    processedProps = this._schemaMapper.applyDefaults(processedProps);\n\n    // Apply property transformations if enabled\n    if (props.enableTransformation !== false) {\n      // For transformation, we would need a source schema, but since we're not\n      // migrating from a different version in this context, we'll skip transformation\n      // This would be used when upgrading from one version to another\n    }\n\n    return processedProps;\n  }\n\n  /**\n   * Validates properties against the schema\n   */\n  private _validateProperties(props: any): ValidationResult {\n    return this._schemaMapper.validateProperties(props);\n  }\n\n  /**\n   * Performs migration analysis for the current version\n   */\n  private _performMigrationAnalysis(): MigrationAnalysis | undefined {\n    // Check if the current version is deprecated\n    if (\n      this.versionConfig.supportLevel === VersionSupportLevel.DEPRECATED ||\n      this.versionConfig.supportLevel === VersionSupportLevel.SUNSET\n    ) {\n      const latestVersion = this.latestVersion();\n      if (latestVersion && latestVersion !== this.resolvedApiVersion) {\n        return this._apiVersionManager.analyzeMigration(\n          this.resourceType(),\n          this.resolvedApiVersion,\n          latestVersion,\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Creates the underlying Azure resource\n   */\n  private _createAzureResource(props: any): void {\n    // Create the resource body using the subclass implementation\n    const resourceBody = this.createResourceBody(props);\n\n    // Determine the parent ID using the overrideable method\n    const parentId = this.resolveParentId(props);\n\n    // Create the AZAPI resource using the base class method\n    this.terraformResource = this.createAzapiResource(\n      resourceBody,\n      parentId,\n      this.name,\n      this.location,\n    );\n  }\n\n  /**\n   * Resolves the parent resource ID for this resource.\n   *\n   * Override this method in child resource classes (like Subnet) that need\n   * custom parent ID resolution logic. By default, this delegates to the\n   * private _determineParentId method which handles standard resource types.\n   *\n   * @param props - The resource properties\n   * @returns The parent resource ID\n   */\n  protected resolveParentId(props: any): string {\n    return this._determineParentId(props);\n  }\n\n  /**\n   * Determines the parent ID for the resource (internal implementation)\n   *\n   * This method provides the default parent ID resolution logic for most resources.\n   * Child resources should override resolveParentId() instead of this method.\n   */\n  private _determineParentId(props: any): string {\n    // This is a simplified implementation - real implementation would be\n    // resource-type specific and could be made abstract or configurable\n\n    // For resource groups, parent is subscription\n    if (this.resourceType() === \"Microsoft.Resources/resourceGroups\") {\n      // Use AZAPI client config to get subscription ID\n      const clientConfig = new DataAzapiClientConfig(this, \"client_config\", {});\n      return `/subscriptions/\\${${clientConfig.fqn}.subscription_id}`;\n    }\n\n    // For other resources, parent might be resource group\n    if (props.resourceGroupId) {\n      return props.resourceGroupId;\n    }\n\n    // Default to subscription\n    const clientConfig = new DataAzapiClientConfig(\n      this,\n      \"client_config_default\",\n      {},\n    );\n    return `/subscriptions/\\${${clientConfig.fqn}.subscription_id}`;\n  }\n\n  /**\n   * Logs framework messages including warnings and migration guidance\n   */\n  private _logFrameworkMessages(): void {\n    // ANSI color codes for terminal output\n    const RED = \"\\x1b[31m\";\n    const YELLOW = \"\\x1b[33m\";\n    const RESET = \"\\x1b[0m\";\n    const BOLD = \"\\x1b[1m\";\n\n    // Log deprecation warnings\n    if (this.versionConfig.supportLevel === VersionSupportLevel.DEPRECATED) {\n      console.warn(\n        `${YELLOW}⚠️  API version ${this.resolvedApiVersion} for ${this.resourceType()} is deprecated. ` +\n          `Consider upgrading to the latest version: ${this.latestVersion()}${RESET}`,\n      );\n    }\n\n    if (this.versionConfig.supportLevel === VersionSupportLevel.SUNSET) {\n      console.error(\n        `${RED}${BOLD}🚨 API version ${this.resolvedApiVersion} for ${this.resourceType()} has reached sunset. ` +\n          `Immediate migration to ${this.latestVersion()} is required.${RESET}`,\n      );\n    }\n\n    // Log migration analysis results\n    if (this.migrationAnalysis && !this.migrationAnalysis.compatible) {\n      console.warn(\n        `${YELLOW}Migration from ${this.migrationAnalysis.fromVersion} to ${this.migrationAnalysis.toVersion} ` +\n          `has ${this.migrationAnalysis.breakingChanges.length} breaking changes. ` +\n          `Estimated effort: ${this.migrationAnalysis.estimatedEffort}${RESET}`,\n      );\n    }\n\n    // Log validation warnings\n    if (this.validationResult?.warnings.length) {\n      this.validationResult.warnings.forEach((warning) => {\n        console.warn(\n          `${YELLOW}Property validation warning: ${warning}${RESET}`,\n        );\n      });\n    }\n  }\n\n  // =============================================================================\n  // MONITORING INTEGRATION METHODS\n  // =============================================================================\n\n  /**\n   * Creates monitoring resources based on the monitoring configuration\n   *\n   * This method is called automatically during construction if monitoring is configured.\n   * It creates action groups, metric alerts, and activity log alerts as child constructs.\n   *\n   * Protected to allow subclasses to override or extend monitoring behavior.\n   *\n   * @param config - The monitoring configuration from props\n   */\n  protected async createMonitoringResources(\n    config: MonitoringConfig,\n  ): Promise<void> {\n    // Skip if monitoring is explicitly disabled\n    if (config.enabled === false) {\n      return;\n    }\n\n    // Create diagnostic settings using dynamic import to avoid circular dependency\n    if (config.diagnosticSettings) {\n      const { DiagnosticSettings } = await import(\n        \"../../../azure-diagnosticsettings/lib/diagnostic-settings\"\n      );\n      new DiagnosticSettings(this, \"monitoring-diagnostic-settings\", {\n        ...config.diagnosticSettings,\n        targetResourceId: this.resourceId,\n      });\n    }\n\n    // Create action groups using dynamic import\n    if (config.actionGroups && config.actionGroups.length > 0) {\n      const { ActionGroup } = await import(\n        \"../../../azure-actiongroup/lib/action-group\"\n      );\n      config.actionGroups.forEach((actionGroupProps, index) => {\n        const actionGroup = new ActionGroup(\n          this,\n          `monitoring-action-group-${index}`,\n          actionGroupProps,\n        );\n        this.monitoringActionGroups.push(actionGroup);\n      });\n    }\n\n    // Create metric alerts using dynamic import\n    if (config.metricAlerts && config.metricAlerts.length > 0) {\n      const { MetricAlert } = await import(\n        \"../../../azure-metricalert/lib/metric-alert\"\n      );\n      config.metricAlerts.forEach((metricAlertProps, index) => {\n        // If scopes not provided, default to this resource\n        const propsWithScope: MetricAlertProps = {\n          ...metricAlertProps,\n          scopes: metricAlertProps.scopes || [this.resourceId],\n        };\n\n        const metricAlert = new MetricAlert(\n          this,\n          `monitoring-metric-alert-${index}`,\n          propsWithScope,\n        );\n        this.monitoringMetricAlerts.push(metricAlert);\n      });\n    }\n\n    // Create activity log alerts using dynamic import\n    if (config.activityLogAlerts && config.activityLogAlerts.length > 0) {\n      const { ActivityLogAlert } = await import(\n        \"../../../azure-activitylogalert/lib/activity-log-alert\"\n      );\n      config.activityLogAlerts.forEach((activityLogAlertProps, index) => {\n        // If scopes not provided, default to this resource\n        const propsWithScope: ActivityLogAlertProps = {\n          ...activityLogAlertProps,\n          scopes: activityLogAlertProps.scopes || [this.resourceId],\n        };\n\n        const activityLogAlert = new ActivityLogAlert(\n          this,\n          `monitoring-activity-log-alert-${index}`,\n          propsWithScope,\n        );\n        this.monitoringActivityLogAlerts.push(activityLogAlert);\n      });\n    }\n  }\n\n  // =============================================================================\n  // RESOURCE MANAGEMENT METHODS (from AzapiResource)\n  // =============================================================================\n\n  /**\n   * Creates the underlying AZAPI Terraform resource using the generated provider classes\n   *\n   * @param properties - The properties object to send to the Azure API\n   * @param parentId - The parent resource ID (e.g., subscription or resource group)\n   * @param name - The name of the resource\n   * @param location - The location of the resource (optional, can be in properties)\n   * @returns The created AZAPI resource\n   */\n  protected createAzapiResource(\n    properties: Record<string, any>,\n    parentId: string,\n    name: string,\n    location?: string,\n  ): cdktf.TerraformResource {\n    // Build the configuration object for the generated AZAPI Resource class\n    const config: ResourceConfig = {\n      type: `${this._resourceType}@${this.apiVersion}`,\n      name: name,\n      parentId: parentId,\n      body: properties,\n      // Add location conditionally if provided and not already in properties\n      ...(location && !properties.location && { location: location }),\n    };\n\n    // Create and return the AZAPI resource using the generated provider class\n    return new Resource(this, \"resource\", config);\n  }\n\n  /**\n   * Creates an AZAPI data source for reading existing resources\n   *\n   * @param resourceId - The full resource ID\n   * @returns The created Terraform data source\n   */\n  protected createAzapiDataSource(\n    resourceId: string,\n  ): cdktf.TerraformDataSource {\n    const dataSource = new cdktf.TerraformDataSource(this, \"data\", {\n      terraformResourceType: \"azapi_resource\",\n      terraformGeneratorMetadata: {\n        providerName: \"azapi\",\n      },\n    });\n\n    dataSource.addOverride(\"type\", this._resourceType);\n    dataSource.addOverride(\"resource_id\", resourceId);\n\n    return dataSource;\n  }\n\n  /**\n   * Updates the resource with new properties\n   *\n   * @param properties - The new properties to apply\n   */\n  protected updateAzapiResource(properties: Record<string, any>): void {\n    if (this.terraformResource) {\n      this.terraformResource.addOverride(\"body\", properties);\n    }\n  }\n\n  /**\n   * Gets the full resource ID\n   */\n  public get resourceId(): string {\n    return this.terraformResource?.fqn || this.id;\n  }\n\n  /**\n   * Gets the resource as a Terraform output value\n   */\n  public get output(): cdktf.TerraformOutput {\n    return new cdktf.TerraformOutput(this, \"output\", {\n      value: this.terraformResource?.fqn,\n    });\n  }\n\n  /**\n   * Adds an access role assignment for a specified Azure AD object\n   *\n   * Note: This method creates role assignments using AZAPI instead of AzureRM provider.\n   *\n   * @param objectId - The unique identifier of the Azure AD object\n   * @param roleDefinitionName - The name of the Azure RBAC role to be assigned\n   */\n  public addAccess(objectId: string, roleDefinitionName: string): void {\n    new AzapiRoleAssignment(this, `rbac-${objectId}-${roleDefinitionName}`, {\n      objectId: objectId,\n      roleDefinitionName: roleDefinitionName,\n      scope: this.resourceId,\n    });\n  }\n}\n\n// =============================================================================\n// HELPER CLASSES AND INTERFACES\n// =============================================================================\n\n/**\n * Properties for AZAPI role assignment\n */\nexport interface AzapiRoleAssignmentProps {\n  readonly objectId: string;\n  readonly roleDefinitionName: string;\n  readonly scope: string;\n}\n\n/**\n * AZAPI-based role assignment construct\n */\nexport class AzapiRoleAssignment extends Construct {\n  constructor(scope: Construct, id: string, props: AzapiRoleAssignmentProps) {\n    super(scope, id);\n\n    const properties = {\n      principalId: props.objectId,\n      roleDefinitionId: `[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionId('${props.roleDefinitionName}'))]`,\n      scope: props.scope,\n    };\n\n    const config: ResourceConfig = {\n      type: \"Microsoft.Authorization/roleAssignments\",\n      name: \"[guid()]\",\n      parentId: props.scope,\n      body: properties,\n    };\n    new Resource(this, \"role-assignment\", config);\n  }\n}\n"]}
+AzapiRoleAssignment[_b] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiRoleAssignment", version: "1.3.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azapi-resource.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/azapi-resource.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AzapiResource - A unified framework for version-aware Azure resource management\n *\n * This abstract base class provides a self-contained unified framework approach\n * for Azure resource management with automatic version management, schema-driven\n * property transformation, and migration analysis capabilities.\n *\n * Key Features:\n * - Automatic latest version resolution when no version is specified\n * - Support for explicit version pinning for stability\n * - Schema-driven property transformation between versions\n * - Migration analysis and deprecation warnings\n * - Built-in role assignment and diagnostic settings support\n * - JSII-compliant design for multi-language support\n *\n * This class replaces the previous dual-class approach (AzapiResource + AzapiResource)\n * with a single, self-contained implementation that handles all resource management needs.\n *\n * @packageDocumentation\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { DataAzapiClientConfig } from \"./providers-azapi/data-azapi-client-config\";\nimport { Resource, ResourceConfig } from \"./providers-azapi/resource\";\nimport { ResourceSchemaValidator } from \"./resource-schema-validator\";\nimport { ResourceVersionManager } from \"./resource-version-manager\";\n\n// Type-only imports to avoid circular dependencies\nimport type { ActionGroupProps } from \"../../../azure-actiongroup/lib/action-group\";\nimport type { ActivityLogAlertProps } from \"../../../azure-activitylogalert/lib/activity-log-alert\";\nimport type { DiagnosticSettingsProps } from \"../../../azure-diagnosticsettings/lib/diagnostic-settings\";\nimport type { MetricAlertProps } from \"../../../azure-metricalert/lib/metric-alert\";\nimport { ApiVersionManager } from \"../version-manager/api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  ValidationResult,\n  MigrationAnalysis,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n/**\n * Retention policy configuration\n */\nexport interface RetentionPolicyConfig {\n  readonly enabled: boolean;\n  readonly days: number;\n}\n\n/**\n * Log configuration for diagnostic settings\n */\nexport interface DiagnosticLogConfig {\n  readonly category?: string;\n  readonly categoryGroup?: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Metric configuration for diagnostic settings\n */\nexport interface DiagnosticMetricConfig {\n  /** Metric category name (used in newer API versions) */\n  readonly category?: string;\n  /** Time grain for metrics in ISO 8601 duration format (used in API version 2016-09-01, e.g., \"PT1M\") */\n  readonly timeGrain?: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Monitoring configuration for Azure resources\n *\n * Provides integrated monitoring capabilities including diagnostic settings,\n * metric alerts, and activity log alerts. All monitoring is optional and\n * disabled by default.\n */\nexport interface MonitoringConfig {\n  /**\n   * Whether monitoring is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Diagnostic settings configuration\n   * Uses the full DiagnosticSettings construct for consistency\n   */\n  readonly diagnosticSettings?: DiagnosticSettingsProps;\n\n  /**\n   * Action groups to create for this resource\n   * Creates new ActionGroup instances as child constructs\n   */\n  readonly actionGroups?: ActionGroupProps[];\n\n  /**\n   * Metric alerts configuration\n   * Creates MetricAlert instances scoped to this resource\n   */\n  readonly metricAlerts?: MetricAlertProps[];\n\n  /**\n   * Activity log alerts configuration\n   * Creates ActivityLogAlert instances for this resource's operations\n   */\n  readonly activityLogAlerts?: ActivityLogAlertProps[];\n}\n\n/**\n * Properties for versioned Azure resources\n *\n * Combines base resource properties with version management capabilities\n * and advanced configuration options for the unified framework.\n */\nexport interface AzapiResourceProps extends cdktf.TerraformMetaArguments {\n  /**\n   * The name of the resource\n   */\n  readonly name?: string;\n\n  /**\n   * The location where the resource should be created\n   *\n   * @remarks\n   * Location handling varies by resource type:\n   * - **Top-level resources**: Most require an explicit location (e.g., \"eastus\", \"westus\")\n   * - **Global resources**: Some use \"global\" as location (e.g., Private DNS Zones)\n   * - **Child resources**: Inherit location from parent and should NOT set this property\n   *\n   * Each resource type may provide its own default through the `resolveLocation()` method.\n   * If no location is specified and no default exists, resource creation may fail.\n   *\n   * @example\n   * // Explicit location for most resources\n   * location: \"eastus\"\n   *\n   * @example\n   * // Global resource (Private DNS Zone)\n   * location: \"global\"\n   *\n   * @example\n   * // Child resource (Subnet) - do not set location\n   * // location: undefined (inherited from parent Virtual Network)\n   *\n   * @defaultValue Varies by resource type - see specific resource documentation\n   */\n  readonly location?: string;\n\n  /**\n   * Tags to apply to the resource\n   */\n  readonly tags?: Record<string, string>;\n  /**\n   * Explicit API version to use for this resource\n   *\n   * If not specified, the latest active version will be automatically resolved.\n   * Use this for version pinning when stability is required over latest features.\n   *\n   * @example \"2024-11-01\"\n   * @defaultValue Latest active version from ApiVersionManager\n   */\n  readonly apiVersion?: string;\n\n  /**\n   * Whether to enable migration analysis warnings\n   *\n   * When true, the framework will analyze the current version for deprecation\n   * status and provide migration recommendations in the deployment output.\n   *\n   * @defaultValue true\n   */\n  readonly enableMigrationAnalysis?: boolean;\n\n  /**\n   * Whether to validate properties against the schema\n   *\n   * When true, all properties will be validated against the API schema before\n   * resource creation. Validation errors will cause deployment failures.\n   *\n   * @defaultValue true\n   */\n  readonly enableValidation?: boolean;\n\n  /**\n   * Whether to apply property transformations automatically\n   *\n   * When true, properties will be automatically transformed according to the\n   * target schema's transformation rules. This enables backward compatibility.\n   *\n   * @defaultValue true\n   */\n  readonly enableTransformation?: boolean;\n\n  /**\n   * Monitoring configuration for this resource\n   *\n   * Enables integrated monitoring with diagnostic settings, metric alerts,\n   * and activity log alerts. All monitoring is optional and disabled by default.\n   *\n   * @example\n   * monitoring: {\n   *   enabled: true,\n   *   diagnosticSettings: {\n   *     workspaceId: logAnalytics.id,\n   *     metrics: ['AllMetrics'],\n   *     logs: ['AuditLogs']\n   *   },\n   *   metricAlerts: [{\n   *     name: 'high-cpu-alert',\n   *     severity: 2,\n   *     scopes: [], // Automatically set to this resource\n   *     criteria: { ... },\n   *     actions: [{ actionGroupId: actionGroup.id }]\n   *   }]\n   * }\n   */\n  readonly monitoring?: MonitoringConfig;\n}\n\n/**\n * Abstract base class for version-aware Azure resource management\n *\n * AzapiResource provides a unified framework for creating Azure resources\n * with automatic version management, schema validation, property transformation,\n * and migration analysis. It extends the existing AzapiResource class while\n * maintaining full backward compatibility.\n *\n * This class implements the core framework that enables:\n * - Automatic resolution of the latest API version when none is specified\n * - Explicit version pinning for environments requiring stability\n * - Schema-driven property validation and transformation\n * - Migration analysis with breaking change detection\n * - Deprecation warnings and upgrade recommendations\n *\n * Subclasses must implement the abstract methods to provide resource-specific\n * configuration while the framework handles all version management complexity.\n *\n * @example Basic usage with automatic version resolution:\n * class MyResource extends AzapiResource {\n *   protected getDefaultVersion(): string {\n *     return \"2024-11-01\"; // fallback if no versions registered\n *   }\n *\n *   protected getResourceType(): string {\n *     return \"Microsoft.Resources/resourceGroups\";\n *   }\n *\n *   protected getApiSchema(): ApiSchema {\n *     return this.resolveSchema();\n *   }\n *\n *   protected createResourceBody(props: any): any {\n *     return { location: props.location, tags: props.tags || {} };\n *   }\n * }\n *\n * @example Usage with explicit version pinning:\n * new MyResource(this, \"resource\", {\n *   name: \"my-resource\",\n *   location: \"eastus\",\n *   apiVersion: \"2024-01-01\" // Pin to specific version\n * });\n *\n * @stability stable\n */\nexport abstract class AzapiResource extends Construct {\n  /**\n   * Static helper for child classes to register their schemas in static initializers\n   *\n   * This method should be called in a static initializer block of each child class\n   * to register all supported API versions and their schemas with the ApiVersionManager.\n   * The static block runs once when the class is first loaded, ensuring schemas are\n   * registered before any instances are created.\n   *\n   * @param resourceType - The Azure resource type (e.g., \"Microsoft.Network/virtualNetworks\")\n   * @param versions - Array of version configurations containing schemas\n   *\n   * @example\n   * static {\n   *   AzapiResource.registerSchemas(\n   *     \"Microsoft.Network/virtualNetworks\",\n   *     ALL_VIRTUAL_NETWORK_VERSIONS\n   *   );\n   * }\n   */\n  protected static registerSchemas(\n    resourceType: string,\n    versions: VersionConfig[],\n  ): void {\n    ApiVersionManager.instance().registerResourceType(resourceType, versions);\n  }\n\n  /**\n   * The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   * @internal\n   */\n  protected _resourceType!: string;\n\n  /**\n   * The API version to use for this resource\n   */\n  protected apiVersion: string;\n\n  /**\n   * The underlying AZAPI Terraform resource\n   */\n  protected terraformResource!: cdktf.TerraformResource;\n\n  /**\n   * The name of the resource\n   */\n  public readonly name: string;\n\n  /**\n   * The location of the resource (optional - not all resources have a location)\n   * Child resources typically inherit location from their parent\n   */\n  public readonly location?: string;\n\n  /**\n   * The Azure resource ID\n   *\n   * This property is automatically derived from the underlying Terraform resource.\n   * Child classes no longer need to implement this property.\n   */\n  public get id(): string {\n    return `\\${${this.terraformResource.fqn}.id}`;\n  }\n\n  /**\n   * The resolved API version being used for this resource instance\n   *\n   * This is the actual version that will be used for the Azure API call,\n   * either explicitly specified in props or automatically resolved to\n   * the latest active version.\n   */\n  public resolvedApiVersion: string;\n\n  /**\n   * The API schema for the resolved version\n   *\n   * Contains the complete schema definition including properties, validation\n   * rules, and transformation mappings for the resolved API version.\n   */\n  public schema!: ApiSchema;\n\n  /**\n   * The version configuration for the resolved version\n   *\n   * Contains lifecycle information, breaking changes, and migration metadata\n   * for the resolved API version.\n   */\n  public versionConfig!: VersionConfig;\n\n  /**\n   * Validation results for the resource properties\n   *\n   * Available after construction if validation is enabled. Contains detailed\n   * information about any validation errors or warnings.\n   */\n  public validationResult?: ValidationResult;\n\n  /**\n   * Migration analysis results\n   *\n   * Available after construction if migration analysis is enabled and a\n   * previous version can be determined for comparison.\n   */\n  public migrationAnalysis?: MigrationAnalysis;\n\n  // Framework components\n  private readonly _apiVersionManager: ApiVersionManager;\n  private _versionManager!: ResourceVersionManager;\n  private _schemaValidator!: ResourceSchemaValidator;\n\n  /**\n   * Internal mutable tags storage separate from input props\n   * Combines props.tags with dynamically added tags via addTag()\n   */\n  private _tags: { [key: string]: string };\n\n  // Monitoring resources (protected for subclass access)\n  protected readonly monitoringActionGroups: Construct[] = [];\n  protected readonly monitoringMetricAlerts: Construct[] = [];\n  protected readonly monitoringActivityLogAlerts: Construct[] = [];\n\n  /**\n   * Creates a new AzapiResource instance\n   *\n   * The constructor handles all framework initialization including version resolution,\n   * schema loading, property validation, transformation, and migration analysis.\n   * It maintains full backward compatibility with the AzapiResource constructor.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the resource\n   */\n  constructor(scope: Construct, id: string, props: AzapiResourceProps = {}) {\n    // Initialize the base Construct\n    super(scope, id);\n\n    // Initialize basic properties that don't require abstract methods\n    // Use props.name if provided, otherwise fall back to construct ID\n    // This supports both explicit naming and automatic ID-based naming\n    this.name = this.resolveName(props);\n    this.location = this.resolveLocation(props);\n\n    // Initialize the API version manager\n    this._apiVersionManager = ApiVersionManager.instance();\n\n    // Initialize tags storage with empty object (will be populated in initialize())\n    this._tags = {};\n\n    // Note: We cannot initialize version manager here because it requires\n    // calling abstract methods (resourceType() and defaultVersion())\n    // which are not yet available in the base constructor.\n    // Version resolution is deferred to initialize() method.\n\n    // Step 1: Resolve the API version to use (doesn't call abstract methods yet)\n    // This is a placeholder that will be properly set in initialize()\n    this.resolvedApiVersion = props.apiVersion || \"\";\n    this.apiVersion = this.resolvedApiVersion;\n\n    // Step 2: Call initialize() to complete initialization after child class is ready\n    this.initialize(props);\n  }\n\n  /**\n   * Protected initialization method called after the constructor completes\n   *\n   * This method is called at the end of the constructor to perform initialization\n   * that requires calling abstract methods. Child classes can override this method\n   * if they need to extend initialization logic, but they MUST call super.initialize(props).\n   *\n   * @param props - Configuration properties for the resource\n   */\n  protected initialize(props: AzapiResourceProps): void {\n    // Step 2: Set required abstract properties (now safe to call abstract methods)\n    this._resourceType = this.resourceType();\n\n    // Step 3: Initialize the version manager and resolve the API version\n    this._versionManager = new ResourceVersionManager(\n      this._resourceType,\n      this.defaultVersion(),\n    );\n    this.resolvedApiVersion = this._versionManager.resolveApiVersion(\n      props.apiVersion,\n    );\n    this.apiVersion = this.resolvedApiVersion;\n\n    // Step 3.5: Initialize tags from props\n    // This creates a mutable copy separate from the readonly props\n    this._tags = { ...(props.tags || {}) };\n\n    // Step 4: Load the schema and version configuration using the version manager\n    this.schema = this._versionManager.schemaForVersion(\n      this.resolvedApiVersion,\n    );\n    const versionConfig = this._versionManager.versionConfig(\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Version configuration not found for ${this.resourceType()}@${this.resolvedApiVersion}. ` +\n          `Please ensure the version is registered with the ApiVersionManager.`,\n      );\n    }\n    this.versionConfig = versionConfig;\n\n    // Step 5: Initialize the schema validator\n    this._schemaValidator = new ResourceSchemaValidator(this.schema);\n\n    // Step 6: Process properties through the framework pipeline\n    const processedProps = this._processProperties(props);\n\n    // Step 7: Perform validation if enabled\n    if (props.enableValidation !== false) {\n      this.validationResult =\n        this._schemaValidator.validateProps(processedProps);\n      if (!this.validationResult.valid) {\n        throw new Error(\n          `Property validation failed for ${this.resourceType()}:\\n` +\n            this._schemaValidator\n              .formatValidationErrors(this.validationResult)\n              .join(\"\\n\"),\n        );\n      }\n    }\n\n    // Step 8: Perform migration analysis if enabled\n    if (props.enableMigrationAnalysis !== false) {\n      this.migrationAnalysis = this._performMigrationAnalysis();\n    }\n\n    // Step 9: Create the Azure resource\n    this._createAzureResource(processedProps);\n\n    // Step 10: Create monitoring resources if configured\n    // Note: Monitoring resources are created lazily to avoid circular dependencies\n    if (props.monitoring) {\n      void this.createMonitoringResources(props.monitoring);\n    }\n\n    // Step 11: Log warnings and migration guidance\n    this._logFrameworkMessages();\n  }\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   *\n   * This method should return a sensible default version that can be used\n   * as a fallback if the ApiVersionManager doesn't have any versions registered\n   * for this resource type.\n   *\n   * @returns The default API version string (e.g., \"2024-11-01\")\n   */\n  protected abstract defaultVersion(): string;\n\n  /**\n   * Gets the Azure resource type for this resource\n   *\n   * This method should return the full Azure resource type identifier that\n   * will be used for API calls and version management.\n   *\n   * @returns The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   */\n  protected abstract resourceType(): string;\n\n  /**\n   * Gets the API schema for the resolved version\n   *\n   * This method should return the complete API schema for the resolved version,\n   * including all property definitions, validation rules, and transformation\n   * mappings. Use the resolveSchema() helper method for standard schema resolution.\n   *\n   * @returns The API schema for the resolved version\n   */\n  protected abstract apiSchema(): ApiSchema;\n\n  /**\n   * Creates the resource body for the Azure API call\n   *\n   * This method should transform the input properties into the JSON body format\n   * expected by the Azure REST API for the resolved version. The framework will\n   * have already applied any necessary property transformations and validation.\n   *\n   * @param props - The processed and validated properties for the resource\n   * @returns The resource body object to send to Azure API\n   */\n  protected abstract createResourceBody(props: any): any;\n\n  /**\n   * Override in child classes to provide default location\n   * @returns Default location or undefined\n   */\n  protected defaultLocation(): string | undefined {\n    return undefined;\n  }\n\n  /**\n   * Override in child classes to indicate if location is required\n   * @returns true if location is mandatory for this resource type\n   */\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  /**\n   * Override in child classes to specify parent resource for location inheritance\n   * @returns Parent resource or undefined\n   */\n  protected parentResourceForLocation(): AzapiResource | undefined {\n    return undefined;\n  }\n\n  /**\n   * Resolves location using template method pattern\n   * Priority: props.location > parent location > default location > validation\n   */\n  protected resolveLocation(props: AzapiResourceProps): string | undefined {\n    // 1. Explicit location in props\n    if (props.location) {\n      return props.location;\n    }\n\n    // 2. Inherit from parent resource\n    const parent = this.parentResourceForLocation();\n    if (parent && parent.location) {\n      return parent.location;\n    }\n\n    // 3. Use child class default\n    const defaultLoc = this.defaultLocation();\n    if (defaultLoc) {\n      return defaultLoc;\n    }\n\n    // 4. Validate if required\n    if (this.requiresLocation()) {\n      throw new Error(\n        `Location is required for ${this.resourceType()} but was not provided ` +\n          `and could not be inherited from parent resource.`,\n      );\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Resolves the name for this resource\n   *\n   * This method centralizes name resolution logic. By default, it uses the\n   * provided name or falls back to the construct ID.\n   *\n   * @param props - The resource properties\n   * @returns The resolved resource name\n   */\n  protected resolveName(props: AzapiResourceProps): string {\n    return props.name || this.node.id;\n  }\n\n  /**\n   * Helper method for standard schema resolution\n   *\n   * Subclasses can use this method to resolve the schema for the current version\n   * from the ApiVersionManager. This provides a standard implementation that\n   * most resources can use without custom logic.\n   *\n   * @returns The API schema for the resolved version\n   * @throws Error if the schema cannot be resolved\n   */\n  protected resolveSchema(): ApiSchema {\n    const versionConfig = this._apiVersionManager.versionConfig(\n      this.resourceType(),\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Cannot resolve schema: version configuration not found for ` +\n          `${this.resourceType()}@${this.resolvedApiVersion}`,\n      );\n    }\n\n    return versionConfig.schema;\n  }\n\n  /**\n   * Gets the latest available version for this resource type\n   *\n   * This method provides access to the latest version resolution logic\n   * for use in subclasses or external tooling.\n   *\n   * @returns The latest available version, or undefined if none found\n   */\n  public latestVersion(): string | undefined {\n    return this._versionManager\n      ? this._versionManager.latestVersion()\n      : this._apiVersionManager.latestVersion(this.resourceType());\n  }\n\n  /**\n   * Gets all supported versions for this resource type\n   *\n   * This method provides access to the version registry for use in\n   * subclasses or external tooling.\n   *\n   * @returns Array of supported version strings, sorted by release date\n   */\n  public supportedVersions(): string[] {\n    return this._versionManager\n      ? this._versionManager.supportedVersions()\n      : this._apiVersionManager.supportedVersions(this.resourceType());\n  }\n\n  /**\n   * Analyzes migration from current version to a target version\n   *\n   * This method enables external tools to analyze migration requirements\n   * between versions for planning and automation purposes.\n   *\n   * @param targetVersion - The target version to analyze migration to\n   * @returns Detailed migration analysis results\n   */\n  public analyzeMigrationTo(targetVersion: string): MigrationAnalysis {\n    return this._apiVersionManager.analyzeMigration(\n      this.resourceType(),\n      this.resolvedApiVersion,\n      targetVersion,\n    );\n  }\n  // =============================================================================\n  // PRIVATE IMPLEMENTATION METHODS\n  // =============================================================================\n\n  /**\n   * Processes properties through the framework pipeline\n   */\n  private _processProperties(props: AzapiResourceProps): any {\n    let processedProps = { ...props };\n\n    // Ensure name is set before processing\n    // This is critical for validation to work correctly\n    if (!processedProps.name) {\n      processedProps.name = this.resolveName(props);\n    }\n\n    // Apply default values from the schema using the validator\n    processedProps = this._schemaValidator.applyDefaults(processedProps);\n\n    // Apply property transformations if enabled\n    if (props.enableTransformation !== false) {\n      // For transformation, we would need a source schema, but since we're not\n      // migrating from a different version in this context, we'll skip transformation\n      // This would be used when upgrading from one version to another\n    }\n\n    return processedProps;\n  }\n\n  /**\n   * Performs migration analysis for the current version\n   */\n  private _performMigrationAnalysis(): MigrationAnalysis | undefined {\n    // Check if the current version is deprecated using the version manager\n    if (this._versionManager.isDeprecated(this.resolvedApiVersion)) {\n      const latestVersion = this._versionManager.latestVersion();\n      if (latestVersion && latestVersion !== this.resolvedApiVersion) {\n        return this._apiVersionManager.analyzeMigration(\n          this.resourceType(),\n          this.resolvedApiVersion,\n          latestVersion,\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Creates the underlying Azure resource\n   */\n  private _createAzureResource(props: any): void {\n    // Ensure name is set in props for validation\n    const propsWithName = {\n      ...props,\n      name: props.name || this.resolveName(props),\n    };\n\n    // Create the resource body using the subclass implementation\n    const resourceBody = this.createResourceBody(propsWithName);\n\n    // Determine the parent ID using the overrideable method\n    const parentId = this.resolveParentId(propsWithName);\n\n    // Find parent AzapiResource construct if parent ID references a resource\n    const parentResource = this._findParentAzapiResource(parentId);\n\n    // Create the AZAPI resource using the base class method\n    const resourceName = this.resolveName(props);\n    this.terraformResource = this.createAzapiResource(\n      resourceBody,\n      parentId,\n      resourceName,\n      this.location,\n      parentResource,\n      propsWithName.dependsOn,\n      this._tags, // Pass tags directly instead of extracting from body\n    );\n  }\n\n  /**\n   * Finds the parent AzapiResource construct if the parentId references a resource\n   * Returns undefined if parentId is a static string or parent not found\n   * @private\n   */\n  private _findParentAzapiResource(\n    parentId: string,\n  ): AzapiResource | undefined {\n    // Check if the parent is a string interpolation referencing another resource\n    // Pattern: ${azapi_resource.resource_name_HASH.id} or ${construct.fqn}.id\n    if (!parentId.includes(\"${\")) {\n      return undefined; // Parent is a static string ID, not a resource reference\n    }\n\n    // Try to find the parent AzapiResource in the construct tree\n    // We need to search the entire tree to find the matching parent\n    const root = this._findRoot();\n    return this._findParentResource(root, parentId);\n  }\n\n  /**\n   * Finds the root of the construct tree\n   * @private\n   */\n  private _findRoot(): Construct {\n    let current: Construct = this;\n    while (current.node.scope) {\n      current = current.node.scope;\n    }\n    return current;\n  }\n\n  /**\n   * Recursively searches for a parent resource by matching parentId patterns\n   * Enhanced to better handle Terraform interpolation syntax\n   * @private\n   */\n  private _findParentResource(\n    scope: Construct,\n    parentId: string,\n  ): AzapiResource | undefined {\n    // Check all children of this scope\n    for (const child of scope.node.children) {\n      if (\n        child instanceof AzapiResource &&\n        child !== this &&\n        child.terraformResource\n      ) {\n        const childFqn = child.terraformResource.fqn;\n\n        // Match if the child's FQN appears anywhere in the parentId string\n        // This handles cases like: ${azapi_resource.dns-resolver_resource_F1517BE4.id}\n        // where childFqn would be: azapi_resource.dns-resolver_resource_F1517BE4\n        if (parentId.includes(childFqn)) {\n          return child;\n        }\n      }\n\n      // Recursively search in child's subtree\n      const found = this._findParentResource(child, parentId);\n      if (found) {\n        return found;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Resolves the parent resource ID for this resource.\n   *\n   * Override this method in child resource classes (like Subnet) that need\n   * custom parent ID resolution logic. By default, this delegates to the\n   * private _determineParentId method which handles standard resource types.\n   *\n   * @param props - The resource properties\n   * @returns The parent resource ID\n   */\n  protected resolveParentId(props: any): string {\n    return this._determineParentId(props);\n  }\n\n  /**\n   * Determines the parent ID for the resource (internal implementation)\n   *\n   * This method provides the default parent ID resolution logic.\n   * Resource-specific logic should be implemented in the overrideable resolveParentId() method.\n   *\n   * Default behavior:\n   * - If resourceGroupId is provided in props, use it\n   * - Otherwise, default to subscription scope\n   */\n  private _determineParentId(props: any): string {\n    // If resource group ID is provided, use it as parent\n    if (props.resourceGroupId) {\n      return props.resourceGroupId;\n    }\n\n    // Default to subscription scope for resources without explicit parent\n    const clientConfig = new DataAzapiClientConfig(\n      this,\n      \"client_config_default\",\n      {},\n    );\n    return `/subscriptions/\\${${clientConfig.fqn}.subscription_id}`;\n  }\n\n  /**\n   * Logs framework messages including warnings and migration guidance\n   */\n  private _logFrameworkMessages(): void {\n    // ANSI color codes for terminal output\n    const RED = \"\\x1b[31m\";\n    const YELLOW = \"\\x1b[33m\";\n    const RESET = \"\\x1b[0m\";\n    const BOLD = \"\\x1b[1m\";\n\n    // Log deprecation warnings using the version manager\n    if (\n      this._versionManager.isDeprecated(this.resolvedApiVersion) &&\n      !this._versionManager.isSunset(this.resolvedApiVersion)\n    ) {\n      console.warn(\n        `${YELLOW}⚠️  API version ${this.resolvedApiVersion} for ${this.resourceType()} is deprecated. ` +\n          `Consider upgrading to the latest version: ${this.latestVersion()}${RESET}`,\n      );\n    }\n\n    if (this._versionManager.isSunset(this.resolvedApiVersion)) {\n      console.error(\n        `${RED}${BOLD}🚨 API version ${this.resolvedApiVersion} for ${this.resourceType()} has reached sunset. ` +\n          `Immediate migration to ${this.latestVersion()} is required.${RESET}`,\n      );\n    }\n\n    // Log migration analysis results\n    if (this.migrationAnalysis && !this.migrationAnalysis.compatible) {\n      console.warn(\n        `${YELLOW}Migration from ${this.migrationAnalysis.fromVersion} to ${this.migrationAnalysis.toVersion} ` +\n          `has ${this.migrationAnalysis.breakingChanges.length} breaking changes. ` +\n          `Estimated effort: ${this.migrationAnalysis.estimatedEffort}${RESET}`,\n      );\n    }\n\n    // Log validation warnings\n    if (this.validationResult?.warnings.length) {\n      this.validationResult.warnings.forEach((warning) => {\n        console.warn(\n          `${YELLOW}Property validation warning: ${warning}${RESET}`,\n        );\n      });\n    }\n  }\n\n  // =============================================================================\n  // MONITORING INTEGRATION METHODS\n  // =============================================================================\n\n  /**\n   * Creates monitoring resources based on the monitoring configuration\n   *\n   * This method is called automatically during construction if monitoring is configured.\n   * It creates action groups, metric alerts, and activity log alerts as child constructs.\n   *\n   * Protected to allow subclasses to override or extend monitoring behavior.\n   *\n   * @param config - The monitoring configuration from props\n   */\n  protected async createMonitoringResources(\n    config: MonitoringConfig,\n  ): Promise<void> {\n    // Skip if monitoring is explicitly disabled\n    if (config.enabled === false) {\n      return;\n    }\n\n    // Create diagnostic settings using dynamic import to avoid circular dependency\n    if (config.diagnosticSettings) {\n      const { DiagnosticSettings } = await import(\n        \"../../../azure-diagnosticsettings/lib/diagnostic-settings\"\n      );\n      new DiagnosticSettings(this, \"monitoring-diagnostic-settings\", {\n        ...config.diagnosticSettings,\n        targetResourceId: this.resourceId,\n      });\n    }\n\n    // Create action groups using dynamic import\n    if (config.actionGroups && config.actionGroups.length > 0) {\n      const { ActionGroup } = await import(\n        \"../../../azure-actiongroup/lib/action-group\"\n      );\n      config.actionGroups.forEach((actionGroupProps, index) => {\n        const actionGroup = new ActionGroup(\n          this,\n          `monitoring-action-group-${index}`,\n          actionGroupProps,\n        );\n        this.monitoringActionGroups.push(actionGroup);\n      });\n    }\n\n    // Create metric alerts using dynamic import\n    if (config.metricAlerts && config.metricAlerts.length > 0) {\n      const { MetricAlert } = await import(\n        \"../../../azure-metricalert/lib/metric-alert\"\n      );\n      config.metricAlerts.forEach((metricAlertProps, index) => {\n        // If scopes not provided, default to this resource\n        const propsWithScope: MetricAlertProps = {\n          ...metricAlertProps,\n          scopes: metricAlertProps.scopes || [this.resourceId],\n        };\n\n        const metricAlert = new MetricAlert(\n          this,\n          `monitoring-metric-alert-${index}`,\n          propsWithScope,\n        );\n        this.monitoringMetricAlerts.push(metricAlert);\n      });\n    }\n\n    // Create activity log alerts using dynamic import\n    if (config.activityLogAlerts && config.activityLogAlerts.length > 0) {\n      const { ActivityLogAlert } = await import(\n        \"../../../azure-activitylogalert/lib/activity-log-alert\"\n      );\n      config.activityLogAlerts.forEach((activityLogAlertProps, index) => {\n        // If scopes not provided, default to this resource\n        const propsWithScope: ActivityLogAlertProps = {\n          ...activityLogAlertProps,\n          scopes: activityLogAlertProps.scopes || [this.resourceId],\n        };\n\n        const activityLogAlert = new ActivityLogAlert(\n          this,\n          `monitoring-activity-log-alert-${index}`,\n          propsWithScope,\n        );\n        this.monitoringActivityLogAlerts.push(activityLogAlert);\n      });\n    }\n  }\n\n  // =============================================================================\n  // RESOURCE MANAGEMENT METHODS (from AzapiResource)\n  // =============================================================================\n\n  /**\n   * Creates the underlying AZAPI Terraform resource using the generated provider classes\n   *\n   * @param properties - The properties object to send to the Azure API (should include location if needed)\n   * @param parentId - The parent resource ID (e.g., subscription or resource group)\n   * @param name - The name of the resource\n   * @param location - The location of the resource (optional, only for top-level resources without location in body)\n   * @param parentResource - The parent resource for dependency tracking\n   * @param dependsOn - Explicit dependencies for this resource\n   * @param tags - Tags to apply to the resource (passed separately from body for proper idempotency)\n   * @returns The created AZAPI resource\n   */\n  protected createAzapiResource(\n    properties: Record<string, any>,\n    parentId: string,\n    name: string,\n    location?: string,\n    parentResource?: AzapiResource,\n    dependsOn?: cdktf.ITerraformDependable[],\n    tags?: Record<string, string>,\n  ): cdktf.TerraformResource {\n    // Determine if this is a child resource by counting path segments\n    // Child resources have multiple segments (e.g., \"Microsoft.Network/virtualNetworks/subnets\")\n    // Top-level resources have one segment (e.g., \"Microsoft.Network/virtualNetworks\")\n    const resourceTypeParts = this._resourceType.split(\"/\");\n    const isChildResource = resourceTypeParts.length > 2;\n\n    // Remove tags from properties to avoid duplicate specification error\n    // The AZAPI provider requires tags at the top level only, not in the body\n    // This prevents: \"can't specify both the argument 'tags' and 'tags' in the argument 'body'\"\n    // Tags are now passed as a separate parameter for better clarity and idempotency\n    const bodyWithoutTags = { ...properties };\n    delete bodyWithoutTags.tags;\n\n    // Build the configuration object for the generated AZAPI Resource class\n    // Add location only if:\n    // 1. This is a top-level resource (not a child resource)\n    // 2. Location is provided as parameter\n    // 3. Location is not already in the body\n    // Child resources inherit location from their parent and should not specify it\n\n    // Combine dependsOn arrays: explicit dependencies + parent resource dependency\n    const combinedDependsOn: cdktf.ITerraformDependable[] = [];\n    if (dependsOn && dependsOn.length > 0) {\n      combinedDependsOn.push(...dependsOn);\n    }\n\n    // CRITICAL: Always add parent dependency when parent_id contains interpolations\n    // This ensures proper destroy-time ordering even if parent detection fails\n    if (parentResource?.terraformResource) {\n      combinedDependsOn.push(parentResource.terraformResource);\n    }\n\n    const config: ResourceConfig = {\n      type: `${this._resourceType}@${this.apiVersion}`,\n      name: name,\n      parentId: parentId,\n      body: bodyWithoutTags,\n      ...(!isChildResource && location && !properties.location && { location }),\n      // Add tags at the top level if they exist\n      // Tags are passed as a separate parameter and added here to ensure they're in the\n      // initial Terraform configuration, providing proper idempotency\n      ...(tags && Object.keys(tags).length > 0 && { tags }),\n      // Add depends_on for explicit dependencies and parent resource\n      ...(combinedDependsOn.length > 0 && { dependsOn: combinedDependsOn }),\n    };\n\n    // Create the AZAPI resource using the generated provider class\n    return new Resource(this, \"resource\", config);\n  }\n\n  /**\n   * Creates an AZAPI data source for reading existing resources\n   *\n   * @param resourceId - The full resource ID\n   * @returns The created Terraform data source\n   */\n  protected createAzapiDataSource(\n    resourceId: string,\n  ): cdktf.TerraformDataSource {\n    const dataSource = new cdktf.TerraformDataSource(this, \"data\", {\n      terraformResourceType: \"azapi_resource\",\n      terraformGeneratorMetadata: {\n        providerName: \"azapi\",\n      },\n    });\n\n    dataSource.addOverride(\"type\", this._resourceType);\n    dataSource.addOverride(\"resource_id\", resourceId);\n\n    return dataSource;\n  }\n\n  /**\n   * Updates the resource with new properties\n   *\n   * @param properties - The new properties to apply\n   */\n  protected updateAzapiResource(properties: Record<string, any>): void {\n    if (this.terraformResource) {\n      this.terraformResource.addOverride(\"body\", properties);\n    }\n  }\n\n  /**\n   * Gets the full resource ID\n   */\n  public get resourceId(): string {\n    return this.terraformResource?.fqn || this.id;\n  }\n\n  /**\n   * Gets the underlying Terraform resource for use in dependency declarations\n   * This allows explicit dependency management between resources\n   */\n  public get resource(): cdktf.TerraformResource {\n    return this.terraformResource;\n  }\n\n  /**\n   * Gets the resource as a Terraform output value\n   */\n  public get output(): cdktf.TerraformOutput {\n    return new cdktf.TerraformOutput(this, \"output\", {\n      value: this.terraformResource?.fqn,\n    });\n  }\n\n  /**\n   * Adds an access role assignment for a specified Azure AD object\n   *\n   * Note: This method creates role assignments using AZAPI instead of AzureRM provider.\n   *\n   * @param objectId - The unique identifier of the Azure AD object\n   * @param roleDefinitionName - The name of the Azure RBAC role to be assigned\n   */\n  public addAccess(objectId: string, roleDefinitionName: string): void {\n    new AzapiRoleAssignment(this, `rbac-${objectId}-${roleDefinitionName}`, {\n      objectId: objectId,\n      roleDefinitionName: roleDefinitionName,\n      scope: this.resourceId,\n    });\n  }\n\n  /**\n   * Adds a tag to this resource. The tag will be included in the Azure resource.\n   *\n   * This method provides proper immutability by storing tags separately from props.\n   * Tags added via this method are combined with tags from props and included in\n   * the deployed Azure resource.\n   *\n   * **Important:** In CDK for Terraform, tags should ideally be set during resource\n   * construction via props. While this method allows adding tags after construction,\n   * those tags are only included if added before the Terraform configuration is\n   * synthesized. For best results, add all tags via props or call addTag() in the\n   * same scope where the resource is created.\n   *\n   * @param key - The tag key\n   * @param value - The tag value\n   */\n  public addTag(key: string, value: string): void {\n    this._tags[key] = value;\n  }\n\n  /**\n   * All tags on this resource (readonly view)\n   *\n   * This getter provides convenient access to all tags including those from props\n   * and those added dynamically via addTag(). Returns a copy to maintain immutability.\n   */\n  public get tags(): { [key: string]: string } {\n    return { ...this._tags };\n  }\n\n  /**\n   * Protected method to retrieve all tags for use in createResourceBody implementations\n   *\n   * Subclasses should use this method when creating resource bodies to ensure\n   * all tags (from props and addTag()) are included in the Azure resource.\n   * Uses a non-getter name to avoid JSII conflicts with the tags property.\n   *\n   * @returns Object containing all tags\n   */\n  protected allTags(): { [key: string]: string } {\n    return { ...this._tags };\n  }\n}\n\n// =============================================================================\n// HELPER CLASSES AND INTERFACES\n// =============================================================================\n\n/**\n * Properties for AZAPI role assignment\n */\nexport interface AzapiRoleAssignmentProps {\n  readonly objectId: string;\n  readonly roleDefinitionName: string;\n  readonly scope: string;\n}\n\n/**\n * AZAPI-based role assignment construct\n */\nexport class AzapiRoleAssignment extends Construct {\n  constructor(scope: Construct, id: string, props: AzapiRoleAssignmentProps) {\n    super(scope, id);\n\n    const properties = {\n      principalId: props.objectId,\n      roleDefinitionId: `[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionId('${props.roleDefinitionName}'))]`,\n      scope: props.scope,\n    };\n\n    const config: ResourceConfig = {\n      type: \"Microsoft.Authorization/roleAssignments\",\n      name: \"[guid()]\",\n      parentId: props.scope,\n      body: properties,\n    };\n    new Resource(this, \"role-assignment\", config);\n  }\n}\n"]}