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

package/lib/azure-metricalert/lib/metric-alert-schemas.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * API schemas for Azure Metric Alert across all supported versions
+ *
+ * This file defines the complete API schemas for Microsoft.Insights/metricAlerts
+ * across all supported API versions. The schemas are used by the AzapiResource
+ * framework for validation, transformation, and version management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METRIC_ALERT_TYPE = exports.ALL_METRIC_ALERT_VERSIONS = exports.METRIC_ALERT_VERSION_2018_03_01 = exports.METRIC_ALERT_SCHEMA_2018_03_01 = void 0;
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+// =============================================================================
+// COMMON PROPERTY DEFINITIONS
+// =============================================================================
+/**
+ * Common property definitions shared across all Metric Alert versions
+ */
+const COMMON_METRIC_ALERT_PROPERTIES = {
+    location: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "Azure region (global for metric alerts)",
+        defaultValue: "global",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Location is required for Metric Alerts",
+            },
+        ],
+    },
+    name: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "Name of the metric alert",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Name is required",
+            },
+        ],
+    },
+    description: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "Description of the alert rule",
+    },
+    severity: {
+        dataType: version_interfaces_1.PropertyType.NUMBER,
+        required: true,
+        description: "Alert severity (0=Critical, 1=Error, 2=Warning, 3=Informational, 4=Verbose)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Severity is required",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.VALUE_RANGE,
+                value: { min: 0, max: 4 },
+                message: "Severity must be between 0 and 4",
+            },
+        ],
+    },
+    enabled: {
+        dataType: version_interfaces_1.PropertyType.BOOLEAN,
+        required: true,
+        defaultValue: true,
+        description: "Enable the alert rule",
+    },
+    scopes: {
+        dataType: version_interfaces_1.PropertyType.ARRAY,
+        required: true,
+        description: "Resource IDs that this alert is scoped to",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "At least one scope is required",
+            },
+        ],
+    },
+    evaluationFrequency: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "How often the alert is evaluated (ISO 8601 duration)",
+        defaultValue: "PT5M",
+    },
+    windowSize: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "Time window for aggregation (ISO 8601 duration)",
+        defaultValue: "PT15M",
+    },
+    targetResourceType: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "Resource type of the target (for multi-resource alerts)",
+    },
+    targetResourceRegion: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "Region of the target resource (for multi-resource alerts)",
+    },
+    criteria: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: true,
+        description: "Alert criteria (static or dynamic threshold)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Criteria is required",
+            },
+        ],
+    },
+    actions: {
+        dataType: version_interfaces_1.PropertyType.ARRAY,
+        required: false,
+        description: "Action groups to notify",
+    },
+    autoMitigate: {
+        dataType: version_interfaces_1.PropertyType.BOOLEAN,
+        required: false,
+        defaultValue: true,
+        description: "Auto-resolve alerts when condition is no longer met",
+    },
+    tags: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        defaultValue: {},
+        description: "Resource tags",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.OBJECT,
+                message: "Tags must be an object with string key-value pairs",
+            },
+        ],
+    },
+};
+// =============================================================================
+// VERSION-SPECIFIC SCHEMAS
+// =============================================================================
+/**
+ * API Schema for Metric Alert version 2018-03-01
+ */
+exports.METRIC_ALERT_SCHEMA_2018_03_01 = {
+    resourceType: "Microsoft.Insights/metricAlerts",
+    version: "2018-03-01",
+    properties: {
+        ...COMMON_METRIC_ALERT_PROPERTIES,
+    },
+    required: [
+        "location",
+        "name",
+        "severity",
+        "enabled",
+        "scopes",
+        "evaluationFrequency",
+        "windowSize",
+        "criteria",
+    ],
+    optional: [
+        "description",
+        "targetResourceType",
+        "targetResourceRegion",
+        "actions",
+        "autoMitigate",
+        "tags",
+    ],
+    deprecated: [],
+    transformationRules: {},
+    validationRules: [
+        {
+            property: "location",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Location is required for Metric Alerts",
+                },
+            ],
+        },
+        {
+            property: "name",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Name is required for Metric Alerts",
+                },
+            ],
+        },
+        {
+            property: "scopes",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "At least one scope is required",
+                },
+            ],
+        },
+        {
+            property: "criteria",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Criteria is required",
+                },
+            ],
+        },
+    ],
+};
+// =============================================================================
+// VERSION CONFIGURATIONS
+// =============================================================================
+/**
+ * Version configuration for Metric Alert 2018-03-01
+ */
+exports.METRIC_ALERT_VERSION_2018_03_01 = {
+    version: "2018-03-01",
+    schema: exports.METRIC_ALERT_SCHEMA_2018_03_01,
+    supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+    releaseDate: "2018-03-01",
+    deprecationDate: undefined,
+    sunsetDate: undefined,
+    breakingChanges: [],
+    migrationGuide: "/docs/metric-alert/migration-2018-03-01",
+    changeLog: [
+        {
+            changeType: "updated",
+            description: "Stable API version for Metric Alerts with dynamic threshold support",
+            breaking: false,
+        },
+    ],
+};
+/**
+ * All supported Metric Alert versions for registration
+ */
+exports.ALL_METRIC_ALERT_VERSIONS = [
+    exports.METRIC_ALERT_VERSION_2018_03_01,
+];
+/**
+ * Resource type constant
+ */
+exports.METRIC_ALERT_TYPE = "Microsoft.Insights/metricAlerts";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-alert-schemas.js","sourceRoot":"","sources":["../../../src/azure-metricalert/lib/metric-alert-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API schemas for Azure Metric Alert across all supported versions\n *\n * This file defines the complete API schemas for Microsoft.Insights/metricAlerts\n * across all supported API versions. The schemas are used by the AzapiResource\n * framework for validation, transformation, and version management.\n */\n\nimport {\n  ApiSchema,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  VersionConfig,\n  VersionSupportLevel,\n} from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n// =============================================================================\n// COMMON PROPERTY DEFINITIONS\n// =============================================================================\n\n/**\n * Common property definitions shared across all Metric Alert versions\n */\nconst COMMON_METRIC_ALERT_PROPERTIES: { [key: string]: PropertyDefinition } = {\n  location: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"Azure region (global for metric alerts)\",\n    defaultValue: \"global\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Location is required for Metric Alerts\",\n      },\n    ],\n  },\n  name: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"Name of the metric alert\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Name is required\",\n      },\n    ],\n  },\n  description: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description: \"Description of the alert rule\",\n  },\n  severity: {\n    dataType: PropertyType.NUMBER,\n    required: true,\n    description:\n      \"Alert severity (0=Critical, 1=Error, 2=Warning, 3=Informational, 4=Verbose)\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Severity is required\",\n      },\n      {\n        ruleType: ValidationRuleType.VALUE_RANGE,\n        value: { min: 0, max: 4 },\n        message: \"Severity must be between 0 and 4\",\n      },\n    ],\n  },\n  enabled: {\n    dataType: PropertyType.BOOLEAN,\n    required: true,\n    defaultValue: true,\n    description: \"Enable the alert rule\",\n  },\n  scopes: {\n    dataType: PropertyType.ARRAY,\n    required: true,\n    description: \"Resource IDs that this alert is scoped to\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"At least one scope is required\",\n      },\n    ],\n  },\n  evaluationFrequency: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"How often the alert is evaluated (ISO 8601 duration)\",\n    defaultValue: \"PT5M\",\n  },\n  windowSize: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"Time window for aggregation (ISO 8601 duration)\",\n    defaultValue: \"PT15M\",\n  },\n  targetResourceType: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description: \"Resource type of the target (for multi-resource alerts)\",\n  },\n  targetResourceRegion: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description: \"Region of the target resource (for multi-resource alerts)\",\n  },\n  criteria: {\n    dataType: PropertyType.OBJECT,\n    required: true,\n    description: \"Alert criteria (static or dynamic threshold)\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Criteria is required\",\n      },\n    ],\n  },\n  actions: {\n    dataType: PropertyType.ARRAY,\n    required: false,\n    description: \"Action groups to notify\",\n  },\n  autoMitigate: {\n    dataType: PropertyType.BOOLEAN,\n    required: false,\n    defaultValue: true,\n    description: \"Auto-resolve alerts when condition is no longer met\",\n  },\n  tags: {\n    dataType: PropertyType.OBJECT,\n    required: false,\n    defaultValue: {},\n    description: \"Resource tags\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.OBJECT,\n        message: \"Tags must be an object with string key-value pairs\",\n      },\n    ],\n  },\n};\n\n// =============================================================================\n// VERSION-SPECIFIC SCHEMAS\n// =============================================================================\n\n/**\n * API Schema for Metric Alert version 2018-03-01\n */\nexport const METRIC_ALERT_SCHEMA_2018_03_01: ApiSchema = {\n  resourceType: \"Microsoft.Insights/metricAlerts\",\n  version: \"2018-03-01\",\n  properties: {\n    ...COMMON_METRIC_ALERT_PROPERTIES,\n  },\n  required: [\n    \"location\",\n    \"name\",\n    \"severity\",\n    \"enabled\",\n    \"scopes\",\n    \"evaluationFrequency\",\n    \"windowSize\",\n    \"criteria\",\n  ],\n  optional: [\n    \"description\",\n    \"targetResourceType\",\n    \"targetResourceRegion\",\n    \"actions\",\n    \"autoMitigate\",\n    \"tags\",\n  ],\n  deprecated: [],\n  transformationRules: {},\n  validationRules: [\n    {\n      property: \"location\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Location is required for Metric Alerts\",\n        },\n      ],\n    },\n    {\n      property: \"name\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Name is required for Metric Alerts\",\n        },\n      ],\n    },\n    {\n      property: \"scopes\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"At least one scope is required\",\n        },\n      ],\n    },\n    {\n      property: \"criteria\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Criteria is required\",\n        },\n      ],\n    },\n  ],\n};\n\n// =============================================================================\n// VERSION CONFIGURATIONS\n// =============================================================================\n\n/**\n * Version configuration for Metric Alert 2018-03-01\n */\nexport const METRIC_ALERT_VERSION_2018_03_01: VersionConfig = {\n  version: \"2018-03-01\",\n  schema: METRIC_ALERT_SCHEMA_2018_03_01,\n  supportLevel: VersionSupportLevel.ACTIVE,\n  releaseDate: \"2018-03-01\",\n  deprecationDate: undefined,\n  sunsetDate: undefined,\n  breakingChanges: [],\n  migrationGuide: \"/docs/metric-alert/migration-2018-03-01\",\n  changeLog: [\n    {\n      changeType: \"updated\",\n      description:\n        \"Stable API version for Metric Alerts with dynamic threshold support\",\n      breaking: false,\n    },\n  ],\n};\n\n/**\n * All supported Metric Alert versions for registration\n */\nexport const ALL_METRIC_ALERT_VERSIONS: VersionConfig[] = [\n  METRIC_ALERT_VERSION_2018_03_01,\n];\n\n/**\n * Resource type constant\n */\nexport const METRIC_ALERT_TYPE = \"Microsoft.Insights/metricAlerts\";\n"]}

package/lib/azure-metricalert/lib/metric-alert.d.ts

@@ -1,56 +1,344 @@
+/**
+ * Unified Azure Metric Alert implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Metric Alerts
+ * that automatically handles version management, schema validation, and property
+ * transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2018-03-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - Support for both static and dynamic threshold criteria
+ */
+import * as cdktf from "cdktf";
 import { Construct } from "constructs";
-import * as model from "../model";
-export declare class MetricAlert extends Construct {
-    readonly props: model.IMetricAlertProps;
+import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
+import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * Metric dimension for filtering
+ */
+export interface MetricDimension {
+    /**
+     * The dimension name
+     */
+    readonly name: string;
+    /**
+     * The operator (Include or Exclude)
+     */
+    readonly operator: "Include" | "Exclude";
+    /**
+     * The dimension values
+     */
+    readonly values: string[];
+}
+/**
+ * Static threshold criteria configuration
+ */
+export interface StaticThresholdCriteria {
+    /**
+     * The criteria type
+     */
+    readonly type: "StaticThreshold";
+    /**
+     * The metric name
+     */
+    readonly metricName: string;
+    /**
+     * The metric namespace (optional)
+     */
+    readonly metricNamespace?: string;
+    /**
+     * The comparison operator
+     */
+    readonly operator: "GreaterThan" | "LessThan" | "GreaterOrEqual" | "LessOrEqual" | "Equals";
+    /**
+     * The threshold value
+     */
+    readonly threshold: number;
+    /**
+     * The time aggregation method
+     */
+    readonly timeAggregation: "Average" | "Count" | "Minimum" | "Maximum" | "Total";
+    /**
+     * Metric dimensions for filtering (optional)
+     */
+    readonly dimensions?: MetricDimension[];
+}
+/**
+ * Metric alert failing periods configuration
+ */
+export interface MetricAlertFailingPeriods {
+    /**
+     * Number of evaluation periods
+     */
+    readonly numberOfEvaluationPeriods: number;
+    /**
+     * Minimum failing periods to trigger alert
+     */
+    readonly minFailingPeriodsToAlert: number;
+}
+/**
+ * Dynamic threshold criteria configuration
+ */
+export interface DynamicThresholdCriteria {
+    /**
+     * The criteria type
+     */
+    readonly type: "DynamicThreshold";
+    /**
+     * The metric name
+     */
+    readonly metricName: string;
+    /**
+     * The metric namespace (optional)
+     */
+    readonly metricNamespace?: string;
+    /**
+     * The comparison operator
+     */
+    readonly operator: "GreaterThan" | "LessThan" | "GreaterOrLessThan";
+    /**
+     * The alert sensitivity (Low, Medium, High)
+     */
+    readonly alertSensitivity: "Low" | "Medium" | "High";
+    /**
+     * Failing periods configuration
+     */
+    readonly failingPeriods: MetricAlertFailingPeriods;
+    /**
+     * The time aggregation method
+     */
+    readonly timeAggregation: "Average" | "Count" | "Minimum" | "Maximum" | "Total";
+    /**
+     * Metric dimensions for filtering (optional)
+     */
+    readonly dimensions?: MetricDimension[];
+    /**
+     * Ignore data before this date (ISO 8601 format)
+     */
+    readonly ignoreDataBefore?: string;
+}
+/**
+ * Metric alert action configuration
+ */
+export interface MetricAlertAction {
+    /**
+     * The action group resource ID
+     */
+    readonly actionGroupId: string;
+    /**
+     * Webhook properties (optional)
+     */
+    readonly webHookProperties?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Properties for the unified Azure Metric Alert
+ *
+ * Extends AzapiResourceProps with Metric Alert specific properties
+ */
+export interface MetricAlertProps extends AzapiResourceProps {
+    /**
+     * Description of the alert rule
+     */
+    readonly description?: string;
+    /**
+     * Alert severity (0=Critical, 1=Error, 2=Warning, 3=Informational, 4=Verbose)
+     * @example 2
+     */
+    readonly severity: 0 | 1 | 2 | 3 | 4;
+    /**
+     * Whether the alert rule is enabled
+     * @defaultValue true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Resource IDs that this alert is scoped to
+     * @example ["/subscriptions/.../resourceGroups/.../providers/Microsoft.Compute/virtualMachines/myVM"]
+     */
+    readonly scopes: string[];
+    /**
+     * How often the alert is evaluated (ISO 8601 duration)
+     * @defaultValue "PT5M"
+     * @example "PT1M", "PT5M", "PT15M"
+     */
+    readonly evaluationFrequency?: string;
+    /**
+     * Time window for aggregation (ISO 8601 duration)
+     * @defaultValue "PT15M"
+     * @example "PT5M", "PT15M", "PT30M", "PT1H"
+     */
+    readonly windowSize?: string;
+    /**
+     * Resource type of the target (for multi-resource alerts)
+     * @example "Microsoft.Compute/virtualMachines"
+     */
+    readonly targetResourceType?: string;
+    /**
+     * Region of the target resource (for multi-resource alerts)
+     * @example "eastus"
+     */
+    readonly targetResourceRegion?: string;
+    /**
+     * Alert criteria (static or dynamic threshold)
+     */
+    readonly criteria: StaticThresholdCriteria | DynamicThresholdCriteria;
+    /**
+     * Action groups to notify
+     */
+    readonly actions?: MetricAlertAction[];
+    /**
+     * Auto-resolve alerts when condition is no longer met
+     * @defaultValue true
+     */
+    readonly autoMitigate?: boolean;
+    /**
+     * Resource group ID where the metric alert will be created
+     */
+    readonly resourceGroupId?: string;
+}
+/**
+ * Metric Alert properties for the request body
+ */
+export interface MetricAlertBodyProperties {
+    readonly description?: string;
+    readonly severity: number;
+    readonly enabled: boolean;
+    readonly scopes: string[];
+    readonly evaluationFrequency: string;
+    readonly windowSize: string;
+    readonly targetResourceType?: string;
+    readonly targetResourceRegion?: string;
+    readonly criteria: any;
+    readonly actions?: MetricAlertAction[];
+    readonly autoMitigate: boolean;
+}
+/**
+ * The resource body interface for Azure Metric Alert API calls
+ */
+export interface MetricAlertBody {
+    readonly location: string;
+    readonly tags?: {
+        [key: string]: string;
+    };
+    readonly properties: MetricAlertBodyProperties;
+}
+/**
+ * Unified Azure Metric Alert implementation
+ *
+ * This class provides a single, version-aware implementation that automatically handles version
+ * resolution, schema validation, and property transformation while maintaining full JSII compliance.
+ *
+ * Metric Alerts monitor Azure resource metrics and trigger notifications when thresholds are breached.
+ * They support both static thresholds and dynamic thresholds based on machine learning.
+ *
+ * @example
+ * // Static threshold alert for VM CPU:
+ * const cpuAlert = new MetricAlert(this, "high-cpu", {
+ *   name: "vm-high-cpu-alert",
+ *   resourceGroupId: resourceGroup.id,
+ *   severity: 2,
+ *   scopes: [virtualMachine.id],
+ *   criteria: {
+ *     type: "StaticThreshold",
+ *     metricName: "Percentage CPU",
+ *     operator: "GreaterThan",
+ *     threshold: 80,
+ *     timeAggregation: "Average"
+ *   },
+ *   actions: [{
+ *     actionGroupId: actionGroup.id
+ *   }]
+ * });
+ *
+ * @example
+ * // Dynamic threshold alert with machine learning:
+ * const dynamicAlert = new MetricAlert(this, "dynamic-cpu", {
+ *   name: "vm-dynamic-cpu-alert",
+ *   resourceGroupId: resourceGroup.id,
+ *   severity: 2,
+ *   scopes: [resourceGroup.id],
+ *   targetResourceType: "Microsoft.Compute/virtualMachines",
+ *   targetResourceRegion: "eastus",
+ *   criteria: {
+ *     type: "DynamicThreshold",
+ *     metricName: "Percentage CPU",
+ *     operator: "GreaterThan",
+ *     alertSensitivity: "Medium",
+ *     failingPeriods: {
+ *       numberOfEvaluationPeriods: 4,
+ *       minFailingPeriodsToAlert: 3
+ *     },
+ *     timeAggregation: "Average"
+ *   },
+ *   actions: [{
+ *     actionGroupId: actionGroup.id
+ *   }]
+ * });
+ *
+ * @stability stable
+ */
+export declare class MetricAlert extends AzapiResource {
+    /**
+     * Static initialization flag to ensure schemas are registered only once
+     */
+    private static schemasRegistered;
+    /**
+     * Ensures that Metric Alert schemas are registered with the ApiVersionManager
+     * This is called once during the first MetricAlert instantiation
+     */
+    private static ensureSchemasRegistered;
+    /**
+     * The input properties for this Metric Alert instance
+     */
+    readonly props: MetricAlertProps;
+    readonly idOutput: cdktf.TerraformOutput;
+    readonly nameOutput: cdktf.TerraformOutput;
     readonly id: string;
     /**
-     * Represents a Metric Alert in Azure Monitor, which is used to automatically monitor metrics across Azure services and trigger actions when certain conditions are met.
-     *
-     * This class encapsulates the configuration and management of a Metric Alert, allowing users to define alert rules based on the metrics from their Azure resources. Metric Alerts can help in proactively managing the health, performance, and availability of Azure services.
-     *
-     * Properties:
-     * - `name`: The name of the Metric Alert, which must be unique within the resource group.
-     * - `description`: Optional. A description of what the Metric Alert monitors and potential impact or remediation.
-     * - `enabled`: Indicates whether the alert rule is enabled. Disabled rules will not fire.
-     * - `autoMitigate`: Specifies whether the alert should attempt auto-mitigation actions when triggered.
-     * - `frequency`: The frequency of evaluation for the alert rule, determining how often the rule is checked.
-     * - `severity`: The severity level assigned to the alert. This helps in categorizing the urgency of the alert.
-     * - `targetResourceType`: Specifies the type of Azure resource the alert rule applies to, necessary for scoping the alert.
-     * - `targetResourceLocation`: Specifies the location of the target resource, required when the alert rule covers resources in multiple locations.
-     * - `windowSize`: The period over which data is collected for analysis, which must be greater than the frequency of evaluation.
-     * - `tags`: User-defined tags to help organize and identify resources within Azure.
-     * - `criteria`: The conditions that trigger the alert. This can be static or dynamic, based on the behavior of the monitored metric over time.
-     * - `dynamicCriteria`: Advanced configurations for criteria that dynamically adjust thresholds based on historical data.
-     * - `scopes`: The specific resources that the Metric Alert is scoped to monitor.
-     * - `resourceGroup`: The Azure Resource Group in which this Metric Alert is defined.
-     *
-     * Example usage:
-     * ```typescript
-     * const cpuAlertProps: IMetricAlertProps = {
-     *   name: 'High CPU Usage Alert',
-     *   resourceGroup: resourceGroupInstance,
-     *   scopes: [vm.id],
-     *   criteria: [
-     *     {
-     *       metricName: 'Percentage CPU',
-     *       operator: 'GreaterThan',
-     *       threshold: 80,
-     *       aggregation: 'Average'
-     *     }
-     *   ],
-     *   frequency: 'PT1M',
-     *   windowSize: 'PT5M',
-     *   severity: 3,
-     *   enabled: true
-     * };
+     * Creates a new Azure Metric Alert using the AzapiResource framework
      *
-     * const cpuAlert = new MetricAlert(this, 'cpuUsageAlert', cpuAlertProps);
-     * ```
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
      *
-     * This configuration defines a Metric Alert that monitors CPU usage across specified virtual machines, triggering an alert if the CPU usage exceeds 80% over a 5-minute window, evaluated every minute.
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Metric Alert
+     */
+    constructor(scope: Construct, id: string, props: MetricAlertProps);
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the most recent stable version as the default
+     */
+    protected defaultVersion(): string;
+    /**
+     * Gets the Azure resource type for Metric Alerts
+     */
+    protected resourceType(): string;
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    protected apiSchema(): ApiSchema;
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     */
+    protected createResourceBody(props: any): any;
+    /**
+     * Add a tag to the Metric Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    addTag(key: string, value: string): void;
+    /**
+     * Remove a tag from the Metric Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
      */
-    constructor(scope: Construct, id: string, props: model.IMetricAlertProps);
-    private ValidatePropsFrequency;
-    private ValidatePropsWindowSize;
-    private ValidatePropsWindowSizeGreaterThanFrequency;
+    removeTag(key: string): void;
 }