@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

package/lib/azure-activitylogalert/lib/activity-log-alert.js

@@ -0,0 +1,212 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityLogAlert = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Activity Log Alert implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Activity Log Alerts
+ * that automatically handles version management, schema validation, and property
+ * transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2020-10-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 filtering by category, operation, and resource type
+ */
+const cdktf = require("cdktf");
+const activity_log_alert_schemas_1 = require("./activity-log-alert-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+/**
+ * Unified Azure Activity Log 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.
+ *
+ * Activity Log Alerts monitor Azure Activity Log events and trigger notifications when specific
+ * operations occur, such as resource deletions, configuration changes, or service health events.
+ *
+ * @example
+ * // Alert on VM deletion:
+ * const vmDeletionAlert = new ActivityLogAlert(this, "vm-deletion", {
+ *   name: "vm-deletion-alert",
+ *   resourceGroupId: resourceGroup.id,
+ *   scopes: ["/subscriptions/00000000-0000-0000-0000-000000000000"],
+ *   condition: {
+ *     allOf: [
+ *       { field: "category", equalsValue: "Administrative" },
+ *       { field: "operationName", equalsValue: "Microsoft.Compute/virtualMachines/delete" },
+ *       { field: "status", equalsValue: "Succeeded" }
+ *     ]
+ *   },
+ *   actions: {
+ *     actionGroups: [{
+ *       actionGroupId: actionGroup.id
+ *     }]
+ *   }
+ * });
+ *
+ * @example
+ * // Alert on service health events:
+ * const serviceHealthAlert = new ActivityLogAlert(this, "service-health", {
+ *   name: "service-health-alert",
+ *   description: "Alert on Azure service health events",
+ *   resourceGroupId: resourceGroup.id,
+ *   scopes: ["/subscriptions/00000000-0000-0000-0000-000000000000"],
+ *   condition: {
+ *     allOf: [
+ *       { field: "category", equalsValue: "ServiceHealth" },
+ *       { field: "properties.incidentType", equalsValue: "Incident" }
+ *     ]
+ *   },
+ *   actions: {
+ *     actionGroups: [{
+ *       actionGroupId: actionGroup.id,
+ *       webhookProperties: {
+ *         severity: "critical"
+ *       }
+ *     }]
+ *   }
+ * });
+ *
+ * @stability stable
+ */
+class ActivityLogAlert extends azapi_resource_1.AzapiResource {
+    /**
+     * Ensures that Activity Log Alert schemas are registered with the ApiVersionManager
+     * This is called once during the first ActivityLogAlert instantiation
+     */
+    static ensureSchemasRegistered() {
+        if (ActivityLogAlert.schemasRegistered) {
+            return;
+        }
+        const apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            // Register all Activity Log Alert versions
+            apiVersionManager.registerResourceType(activity_log_alert_schemas_1.ACTIVITY_LOG_ALERT_TYPE, activity_log_alert_schemas_1.ALL_ACTIVITY_LOG_ALERT_VERSIONS);
+            ActivityLogAlert.schemasRegistered = true;
+            console.log(`Registered ${activity_log_alert_schemas_1.ALL_ACTIVITY_LOG_ALERT_VERSIONS.length} API versions for ${activity_log_alert_schemas_1.ACTIVITY_LOG_ALERT_TYPE}`);
+        }
+        catch (error) {
+            console.warn(`Failed to register Activity Log Alert schemas: ${error}. ` +
+                `This may indicate the schemas are already registered or there's a configuration issue.`);
+            ActivityLogAlert.schemasRegistered = true;
+        }
+    }
+    /**
+     * Creates a new Azure Activity Log Alert using the AzapiResource framework
+     *
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Activity Log Alert
+     */
+    constructor(scope, id, props) {
+        // Ensure schemas are registered before calling super
+        ActivityLogAlert.ensureSchemasRegistered();
+        // Call the parent constructor with the props
+        super(scope, id, props);
+        this.props = props;
+        // Extract properties from the AZAPI resource outputs using Terraform interpolation
+        this.id = `\${${this.terraformResource.fqn}.id}`;
+        // Create Terraform outputs for easy access and referencing from other resources
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Activity Log Alert",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Activity Log Alert",
+        });
+        // Override logical IDs
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the most recent stable version as the default
+     */
+    defaultVersion() {
+        return "2020-10-01";
+    }
+    /**
+     * Gets the Azure resource type for Activity Log Alerts
+     */
+    resourceType() {
+        return activity_log_alert_schemas_1.ACTIVITY_LOG_ALERT_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        // Transform condition to map equalsValue back to equals for Azure API
+        const transformedCondition = {
+            allOf: typedProps.condition.allOf.map((leafCondition) => ({
+                field: leafCondition.field,
+                equals: leafCondition.equalsValue,
+            })),
+        };
+        return {
+            location: "global",
+            tags: typedProps.tags || {},
+            properties: {
+                description: typedProps.description,
+                enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,
+                scopes: typedProps.scopes,
+                condition: transformedCondition,
+                actions: typedProps.actions,
+            },
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR ACTIVITY LOG ALERT OPERATIONS
+    // =============================================================================
+    /**
+     * Add a tag to the Activity Log Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    addTag(key, value) {
+        if (!this.props.tags) {
+            this.props.tags = {};
+        }
+        this.props.tags[key] = value;
+    }
+    /**
+     * Remove a tag from the Activity Log Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    removeTag(key) {
+        if (this.props.tags && this.props.tags[key]) {
+            delete this.props.tags[key];
+        }
+    }
+}
+exports.ActivityLogAlert = ActivityLogAlert;
+_a = JSII_RTTI_SYMBOL_1;
+ActivityLogAlert[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ActivityLogAlert", version: "1.2.0" };
+/**
+ * Static initialization flag to ensure schemas are registered only once
+ */
+ActivityLogAlert.schemasRegistered = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity-log-alert.js","sourceRoot":"","sources":["../../../src/azure-activitylogalert/lib/activity-log-alert.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Activity Log Alert implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Activity Log Alerts\n * that automatically handles version management, schema validation, and property\n * transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2020-10-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full JSII compliance for multi-language support\n * - Support for filtering by category, operation, and resource type\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_ACTIVITY_LOG_ALERT_VERSIONS,\n  ACTIVITY_LOG_ALERT_TYPE,\n} from \"./activity-log-alert-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Activity log alert leaf condition\n */\nexport interface ActivityLogAlertLeafCondition {\n  /**\n   * The field name to filter on\n   * Common values: category, operationName, resourceType, status, subStatus, resourceGroup\n   */\n  readonly field: string;\n\n  /**\n   * The value to match\n   */\n  readonly equalsValue: string;\n}\n\n/**\n * Activity log alert condition\n */\nexport interface ActivityLogAlertCondition {\n  /**\n   * All conditions that must be met (AND logic)\n   */\n  readonly allOf: ActivityLogAlertLeafCondition[];\n}\n\n/**\n * Activity log alert action group reference\n */\nexport interface ActivityLogAlertActionGroup {\n  /**\n   * The action group resource ID\n   */\n  readonly actionGroupId: string;\n\n  /**\n   * Webhook properties (optional)\n   */\n  readonly webhookProperties?: { [key: string]: string };\n}\n\n/**\n * Activity log alert actions configuration\n */\nexport interface ActivityLogAlertActions {\n  /**\n   * Action groups to trigger\n   */\n  readonly actionGroups?: ActivityLogAlertActionGroup[];\n}\n\n/**\n * Properties for the unified Azure Activity Log Alert\n *\n * Extends AzapiResourceProps with Activity Log Alert specific properties\n */\nexport interface ActivityLogAlertProps extends AzapiResourceProps {\n  /**\n   * Description of the alert rule\n   */\n  readonly description?: string;\n\n  /**\n   * Whether the alert rule is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Resource IDs that this alert is scoped to\n   * Can be subscription, resource group, or specific resource IDs\n   * @example [\"/subscriptions/00000000-0000-0000-0000-000000000000\"]\n   * @example [\"/subscriptions/.../resourceGroups/my-rg\"]\n   */\n  readonly scopes: string[];\n\n  /**\n   * Alert condition with field-value pairs\n   * All conditions are combined with AND logic\n   */\n  readonly condition: ActivityLogAlertCondition;\n\n  /**\n   * Action groups to notify\n   */\n  readonly actions?: ActivityLogAlertActions;\n\n  /**\n   * Resource group ID where the activity log alert will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Activity Log Alert properties for the request body\n */\nexport interface ActivityLogAlertBodyProperties {\n  readonly description?: string;\n  readonly enabled: boolean;\n  readonly scopes: string[];\n  readonly condition: ActivityLogAlertCondition;\n  readonly actions?: ActivityLogAlertActions;\n}\n\n/**\n * The resource body interface for Azure Activity Log Alert API calls\n */\nexport interface ActivityLogAlertBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly properties: ActivityLogAlertBodyProperties;\n}\n\n/**\n * Unified Azure Activity Log Alert implementation\n *\n * This class provides a single, version-aware implementation that automatically handles version\n * resolution, schema validation, and property transformation while maintaining full JSII compliance.\n *\n * Activity Log Alerts monitor Azure Activity Log events and trigger notifications when specific\n * operations occur, such as resource deletions, configuration changes, or service health events.\n *\n * @example\n * // Alert on VM deletion:\n * const vmDeletionAlert = new ActivityLogAlert(this, \"vm-deletion\", {\n *   name: \"vm-deletion-alert\",\n *   resourceGroupId: resourceGroup.id,\n *   scopes: [\"/subscriptions/00000000-0000-0000-0000-000000000000\"],\n *   condition: {\n *     allOf: [\n *       { field: \"category\", equalsValue: \"Administrative\" },\n *       { field: \"operationName\", equalsValue: \"Microsoft.Compute/virtualMachines/delete\" },\n *       { field: \"status\", equalsValue: \"Succeeded\" }\n *     ]\n *   },\n *   actions: {\n *     actionGroups: [{\n *       actionGroupId: actionGroup.id\n *     }]\n *   }\n * });\n *\n * @example\n * // Alert on service health events:\n * const serviceHealthAlert = new ActivityLogAlert(this, \"service-health\", {\n *   name: \"service-health-alert\",\n *   description: \"Alert on Azure service health events\",\n *   resourceGroupId: resourceGroup.id,\n *   scopes: [\"/subscriptions/00000000-0000-0000-0000-000000000000\"],\n *   condition: {\n *     allOf: [\n *       { field: \"category\", equalsValue: \"ServiceHealth\" },\n *       { field: \"properties.incidentType\", equalsValue: \"Incident\" }\n *     ]\n *   },\n *   actions: {\n *     actionGroups: [{\n *       actionGroupId: actionGroup.id,\n *       webhookProperties: {\n *         severity: \"critical\"\n *       }\n *     }]\n *   }\n * });\n *\n * @stability stable\n */\nexport class ActivityLogAlert extends AzapiResource {\n  /**\n   * Static initialization flag to ensure schemas are registered only once\n   */\n  private static schemasRegistered = false;\n\n  /**\n   * Ensures that Activity Log Alert schemas are registered with the ApiVersionManager\n   * This is called once during the first ActivityLogAlert instantiation\n   */\n  private static ensureSchemasRegistered(): void {\n    if (ActivityLogAlert.schemasRegistered) {\n      return;\n    }\n\n    const apiVersionManager = ApiVersionManager.instance();\n\n    try {\n      // Register all Activity Log Alert versions\n      apiVersionManager.registerResourceType(\n        ACTIVITY_LOG_ALERT_TYPE,\n        ALL_ACTIVITY_LOG_ALERT_VERSIONS,\n      );\n\n      ActivityLogAlert.schemasRegistered = true;\n\n      console.log(\n        `Registered ${ALL_ACTIVITY_LOG_ALERT_VERSIONS.length} API versions for ${ACTIVITY_LOG_ALERT_TYPE}`,\n      );\n    } catch (error) {\n      console.warn(\n        `Failed to register Activity Log Alert schemas: ${error}. ` +\n          `This may indicate the schemas are already registered or there's a configuration issue.`,\n      );\n      ActivityLogAlert.schemasRegistered = true;\n    }\n  }\n\n  /**\n   * The input properties for this Activity Log Alert instance\n   */\n  public readonly props: ActivityLogAlertProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n\n  // Public properties\n  public readonly id: string;\n\n  /**\n   * Creates a new Azure Activity Log Alert using the AzapiResource framework\n   *\n   * The constructor automatically handles version resolution, schema registration,\n   * validation, and resource creation.\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 Activity Log Alert\n   */\n  constructor(scope: Construct, id: string, props: ActivityLogAlertProps) {\n    // Ensure schemas are registered before calling super\n    ActivityLogAlert.ensureSchemasRegistered();\n\n    // Call the parent constructor with the props\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n    this.id = `\\${${this.terraformResource.fqn}.id}`;\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Activity Log Alert\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Activity Log Alert\",\n    });\n\n    // Override logical IDs\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   * Returns the most recent stable version as the default\n   */\n  protected defaultVersion(): string {\n    return \"2020-10-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Activity Log Alerts\n   */\n  protected resourceType(): string {\n    return ACTIVITY_LOG_ALERT_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   * Uses the framework's schema resolution to get the appropriate schema\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   * Transforms the input properties into the JSON format expected by Azure REST API\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as ActivityLogAlertProps;\n\n    // Transform condition to map equalsValue back to equals for Azure API\n    const transformedCondition = {\n      allOf: typedProps.condition.allOf.map((leafCondition) => ({\n        field: leafCondition.field,\n        equals: leafCondition.equalsValue,\n      })),\n    };\n\n    return {\n      location: \"global\",\n      tags: typedProps.tags || {},\n      properties: {\n        description: typedProps.description,\n        enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,\n        scopes: typedProps.scopes,\n        condition: transformedCondition,\n        actions: typedProps.actions,\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR ACTIVITY LOG ALERT OPERATIONS\n  // =============================================================================\n\n  /**\n   * Add a tag to the Activity Log Alert\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public addTag(key: string, value: string): void {\n    if (!this.props.tags) {\n      (this.props as any).tags = {};\n    }\n    this.props.tags![key] = value;\n  }\n\n  /**\n   * Remove a tag from the Activity Log Alert\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public removeTag(key: string): void {\n    if (this.props.tags && this.props.tags[key]) {\n      delete this.props.tags[key];\n    }\n  }\n}\n"]}

package/lib/azure-activitylogalert/lib/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Azure Activity Log Alert library exports
+ */
+export * from "./activity-log-alert";
+export * from "./activity-log-alert-schemas";

package/lib/azure-activitylogalert/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Azure Activity Log Alert library exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./activity-log-alert"), exports);
+__exportStar(require("./activity-log-alert-schemas"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtYWN0aXZpdHlsb2dhbGVydC9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsdURBQXFDO0FBQ3JDLCtEQUE2QyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQXp1cmUgQWN0aXZpdHkgTG9nIEFsZXJ0IGxpYnJhcnkgZXhwb3J0c1xuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2FjdGl2aXR5LWxvZy1hbGVydFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYWN0aXZpdHktbG9nLWFsZXJ0LXNjaGVtYXNcIjtcbiJdfQ==

package/lib/azure-activitylogalert/test/activity-log-alert.integ.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration test for Azure Activity Log Alert construct
+ *
+ * This test demonstrates basic usage of the ActivityLogAlert construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-activitylogalert/test/activity-log-alert.integ.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Integration test for Azure Activity Log Alert construct
+ *
+ * This test demonstrates basic usage of the ActivityLogAlert construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_actiongroup_1 = require("../../azure-actiongroup");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const activity_log_alert_1 = require("../lib/activity-log-alert");
+/**
+ * Example stack demonstrating ActivityLogAlert usage
+ */
+class ActivityLogAlertExampleStack extends cdktf_1.TerraformStack {
+    constructor(scope, id) {
+        super(scope, id);
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Create resource group
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "rg", {
+            name: "rg-activitylogalert-example",
+            location: "eastus",
+            tags: {
+                environment: "example",
+                purpose: "integration-test",
+            },
+        });
+        // Create action group for alert notifications
+        const actionGroup = new azure_actiongroup_1.ActionGroup(this, "actiongroup", {
+            name: "actiongroup-example",
+            resourceGroupId: resourceGroup.id,
+            apiVersion: "2021-09-01",
+            groupShortName: "Example",
+            enabled: true,
+            emailReceivers: [
+                {
+                    name: "email-example",
+                    emailAddress: "test@example.com",
+                    useCommonAlertSchema: true,
+                },
+            ],
+            tags: {
+                environment: "example",
+            },
+        });
+        // Create activity log alert monitoring administrative operations
+        new activity_log_alert_1.ActivityLogAlert(this, "activitylogalert", {
+            name: "activitylogalert-example",
+            resourceGroupId: resourceGroup.id,
+            apiVersion: "2020-10-01",
+            description: "Alert on administrative resource write operations",
+            enabled: true,
+            scopes: [resourceGroup.id],
+            condition: {
+                allOf: [
+                    {
+                        field: "category",
+                        equalsValue: "Administrative",
+                    },
+                    {
+                        field: "operationName",
+                        equalsValue: "Microsoft.Resources/subscriptions/resourceGroups/write",
+                    },
+                ],
+            },
+            actions: {
+                actionGroups: [
+                    {
+                        actionGroupId: actionGroup.id,
+                    },
+                ],
+            },
+            tags: {
+                environment: "example",
+            },
+        });
+    }
+}
+describe("ActivityLogAlert Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup activity log alert resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new ActivityLogAlertExampleStack(app, "test-activitylogalert");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized);
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9nLWFsZXJ0LmludGVnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F6dXJlLWFjdGl2aXR5bG9nYWxlcnQvdGVzdC9hY3Rpdml0eS1sb2ctYWxlcnQuaW50ZWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7O0dBT0c7O0FBRUgsaUNBQWdEO0FBRWhELDJDQUF5QztBQUN6QywrREFBc0Q7QUFDdEQsbUVBQTBEO0FBQzFELGtGQUFvRjtBQUNwRiwyQ0FBOEQ7QUFDOUQsa0VBQTZEO0FBRTdEOztHQUVHO0FBQ0gsTUFBTSw0QkFBNkIsU0FBUSxzQkFBYztJQUN2RCxZQUFZLEtBQWdCLEVBQUUsRUFBVTtRQUN0QyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLDJCQUEyQjtRQUMzQixJQUFJLHdCQUFhLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQztRQUVyQyx3QkFBd0I7UUFDeEIsTUFBTSxhQUFhLEdBQUcsSUFBSSxtQ0FBYSxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUU7WUFDbEQsSUFBSSxFQUFFLDZCQUE2QjtZQUNuQyxRQUFRLEVBQUUsUUFBUTtZQUNsQixJQUFJLEVBQUU7Z0JBQ0osV0FBVyxFQUFFLFNBQVM7Z0JBQ3RCLE9BQU8sRUFBRSxrQkFBa0I7YUFDNUI7U0FDRixDQUFDLENBQUM7UUFFSCw4Q0FBOEM7UUFDOUMsTUFBTSxXQUFXLEdBQUcsSUFBSSwrQkFBVyxDQUFDLElBQUksRUFBRSxhQUFhLEVBQUU7WUFDdkQsSUFBSSxFQUFFLHFCQUFxQjtZQUMzQixlQUFlLEVBQUUsYUFBYSxDQUFDLEVBQUU7WUFDakMsVUFBVSxFQUFFLFlBQVk7WUFDeEIsY0FBYyxFQUFFLFNBQVM7WUFDekIsT0FBTyxFQUFFLElBQUk7WUFDYixjQUFjLEVBQUU7Z0JBQ2Q7b0JBQ0UsSUFBSSxFQUFFLGVBQWU7b0JBQ3JCLFlBQVksRUFBRSxrQkFBa0I7b0JBQ2hDLG9CQUFvQixFQUFFLElBQUk7aUJBQzNCO2FBQ0Y7WUFDRCxJQUFJLEVBQUU7Z0JBQ0osV0FBVyxFQUFFLFNBQVM7YUFDdkI7U0FDRixDQUFDLENBQUM7UUFFSCxpRUFBaUU7UUFDakUsSUFBSSxxQ0FBZ0IsQ0FBQyxJQUFJLEVBQUUsa0JBQWtCLEVBQUU7WUFDN0MsSUFBSSxFQUFFLDBCQUEwQjtZQUNoQyxlQUFlLEVBQUUsYUFBYSxDQUFDLEVBQUU7WUFDakMsVUFBVSxFQUFFLFlBQVk7WUFDeEIsV0FBVyxFQUFFLG1EQUFtRDtZQUNoRSxPQUFPLEVBQUUsSUFBSTtZQUNiLE1BQU0sRUFBRSxDQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUM7WUFDMUIsU0FBUyxFQUFFO2dCQUNULEtBQUssRUFBRTtvQkFDTDt3QkFDRSxLQUFLLEVBQUUsVUFBVTt3QkFDakIsV0FBVyxFQUFFLGdCQUFnQjtxQkFDOUI7b0JBQ0Q7d0JBQ0UsS0FBSyxFQUFFLGVBQWU7d0JBQ3RCLFdBQVcsRUFDVCx3REFBd0Q7cUJBQzNEO2lCQUNGO2FBQ0Y7WUFDRCxPQUFPLEVBQUU7Z0JBQ1AsWUFBWSxFQUFFO29CQUNaO3dCQUNFLGFBQWEsRUFBRSxXQUFXLENBQUMsRUFBRTtxQkFDOUI7aUJBQ0Y7YUFDRjtZQUNELElBQUksRUFBRTtnQkFDSixXQUFXLEVBQUUsU0FBUzthQUN2QjtTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQUVELFFBQVEsQ0FBQyxtQ0FBbUMsRUFBRSxHQUFHLEVBQUU7SUFDakQsRUFBRSxDQUFDLCtFQUErRSxFQUFFLEdBQUcsRUFBRTtRQUN2RixNQUFNLEdBQUcsR0FBRyxlQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDMUIsTUFBTSxLQUFLLEdBQUcsSUFBSSw0QkFBNEIsQ0FDNUMsR0FBRyxFQUNILHVCQUF1QixDQUN4QixDQUFDO1FBQ0YsTUFBTSxXQUFXLEdBQUcsZUFBTyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUU3QyxhQUFhO1FBQ2IsNkNBQTZDO1FBQzdDLG1FQUFtRTtRQUNuRSxnREFBZ0Q7UUFDaEQsSUFBQSx1Q0FBNkIsRUFBQyxXQUFXLENBQUMsQ0FBQztJQUM3QyxDQUFDLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQywrQ0FBK0M7QUFDN0QsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEludGVncmF0aW9uIHRlc3QgZm9yIEF6dXJlIEFjdGl2aXR5IExvZyBBbGVydCBjb25zdHJ1Y3RcbiAqXG4gKiBUaGlzIHRlc3QgZGVtb25zdHJhdGVzIGJhc2ljIHVzYWdlIG9mIHRoZSBBY3Rpdml0eUxvZ0FsZXJ0IGNvbnN0cnVjdFxuICogYW5kIHZhbGlkYXRlcyBkZXBsb3ltZW50LCBpZGVtcG90ZW5jeSwgYW5kIGNsZWFudXAuXG4gKlxuICogUnVuIHdpdGg6IG5wbSBydW4gaW50ZWdyYXRpb246bm9zdHJlYW1cbiAqL1xuXG5pbXBvcnQgeyBUZXN0aW5nLCBUZXJyYWZvcm1TdGFjayB9IGZyb20gXCJjZGt0ZlwiO1xuaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCBcImNka3RmL2xpYi90ZXN0aW5nL2FkYXB0ZXJzL2plc3RcIjtcbmltcG9ydCB7IEFjdGlvbkdyb3VwIH0gZnJvbSBcIi4uLy4uL2F6dXJlLWFjdGlvbmdyb3VwXCI7XG5pbXBvcnQgeyBSZXNvdXJjZUdyb3VwIH0gZnJvbSBcIi4uLy4uL2F6dXJlLXJlc291cmNlZ3JvdXBcIjtcbmltcG9ydCB7IEF6YXBpUHJvdmlkZXIgfSBmcm9tIFwiLi4vLi4vY29yZS1henVyZS9saWIvYXphcGkvcHJvdmlkZXJzLWF6YXBpL3Byb3ZpZGVyXCI7XG5pbXBvcnQgeyBUZXJyYWZvcm1BcHBseUNoZWNrQW5kRGVzdHJveSB9IGZyb20gXCIuLi8uLi90ZXN0aW5nXCI7XG5pbXBvcnQgeyBBY3Rpdml0eUxvZ0FsZXJ0IH0gZnJvbSBcIi4uL2xpYi9hY3Rpdml0eS1sb2ctYWxlcnRcIjtcblxuLyoqXG4gKiBFeGFtcGxlIHN0YWNrIGRlbW9uc3RyYXRpbmcgQWN0aXZpdHlMb2dBbGVydCB1c2FnZVxuICovXG5jbGFzcyBBY3Rpdml0eUxvZ0FsZXJ0RXhhbXBsZVN0YWNrIGV4dGVuZHMgVGVycmFmb3JtU3RhY2sge1xuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIC8vIENvbmZpZ3VyZSBBWkFQSSBwcm92aWRlclxuICAgIG5ldyBBemFwaVByb3ZpZGVyKHRoaXMsIFwiYXphcGlcIiwge30pO1xuXG4gICAgLy8gQ3JlYXRlIHJlc291cmNlIGdyb3VwXG4gICAgY29uc3QgcmVzb3VyY2VHcm91cCA9IG5ldyBSZXNvdXJjZUdyb3VwKHRoaXMsIFwicmdcIiwge1xuICAgICAgbmFtZTogXCJyZy1hY3Rpdml0eWxvZ2FsZXJ0LWV4YW1wbGVcIixcbiAgICAgIGxvY2F0aW9uOiBcImVhc3R1c1wiLFxuICAgICAgdGFnczoge1xuICAgICAgICBlbnZpcm9ubWVudDogXCJleGFtcGxlXCIsXG4gICAgICAgIHB1cnBvc2U6IFwiaW50ZWdyYXRpb24tdGVzdFwiLFxuICAgICAgfSxcbiAgICB9KTtcblxuICAgIC8vIENyZWF0ZSBhY3Rpb24gZ3JvdXAgZm9yIGFsZXJ0IG5vdGlmaWNhdGlvbnNcbiAgICBjb25zdCBhY3Rpb25Hcm91cCA9IG5ldyBBY3Rpb25Hcm91cCh0aGlzLCBcImFjdGlvbmdyb3VwXCIsIHtcbiAgICAgIG5hbWU6IFwiYWN0aW9uZ3JvdXAtZXhhbXBsZVwiLFxuICAgICAgcmVzb3VyY2VHcm91cElkOiByZXNvdXJjZUdyb3VwLmlkLFxuICAgICAgYXBpVmVyc2lvbjogXCIyMDIxLTA5LTAxXCIsXG4gICAgICBncm91cFNob3J0TmFtZTogXCJFeGFtcGxlXCIsXG4gICAgICBlbmFibGVkOiB0cnVlLFxuICAgICAgZW1haWxSZWNlaXZlcnM6IFtcbiAgICAgICAge1xuICAgICAgICAgIG5hbWU6IFwiZW1haWwtZXhhbXBsZVwiLFxuICAgICAgICAgIGVtYWlsQWRkcmVzczogXCJ0ZXN0QGV4YW1wbGUuY29tXCIsXG4gICAgICAgICAgdXNlQ29tbW9uQWxlcnRTY2hlbWE6IHRydWUsXG4gICAgICAgIH0sXG4gICAgICBdLFxuICAgICAgdGFnczoge1xuICAgICAgICBlbnZpcm9ubWVudDogXCJleGFtcGxlXCIsXG4gICAgICB9LFxuICAgIH0pO1xuXG4gICAgLy8gQ3JlYXRlIGFjdGl2aXR5IGxvZyBhbGVydCBtb25pdG9yaW5nIGFkbWluaXN0cmF0aXZlIG9wZXJhdGlvbnNcbiAgICBuZXcgQWN0aXZpdHlMb2dBbGVydCh0aGlzLCBcImFjdGl2aXR5bG9nYWxlcnRcIiwge1xuICAgICAgbmFtZTogXCJhY3Rpdml0eWxvZ2FsZXJ0LWV4YW1wbGVcIixcbiAgICAgIHJlc291cmNlR3JvdXBJZDogcmVzb3VyY2VHcm91cC5pZCxcbiAgICAgIGFwaVZlcnNpb246IFwiMjAyMC0xMC0wMVwiLFxuICAgICAgZGVzY3JpcHRpb246IFwiQWxlcnQgb24gYWRtaW5pc3RyYXRpdmUgcmVzb3VyY2Ugd3JpdGUgb3BlcmF0aW9uc1wiLFxuICAgICAgZW5hYmxlZDogdHJ1ZSxcbiAgICAgIHNjb3BlczogW3Jlc291cmNlR3JvdXAuaWRdLFxuICAgICAgY29uZGl0aW9uOiB7XG4gICAgICAgIGFsbE9mOiBbXG4gICAgICAgICAge1xuICAgICAgICAgICAgZmllbGQ6IFwiY2F0ZWdvcnlcIixcbiAgICAgICAgICAgIGVxdWFsc1ZhbHVlOiBcIkFkbWluaXN0cmF0aXZlXCIsXG4gICAgICAgICAgfSxcbiAgICAgICAgICB7XG4gICAgICAgICAgICBmaWVsZDogXCJvcGVyYXRpb25OYW1lXCIsXG4gICAgICAgICAgICBlcXVhbHNWYWx1ZTpcbiAgICAgICAgICAgICAgXCJNaWNyb3NvZnQuUmVzb3VyY2VzL3N1YnNjcmlwdGlvbnMvcmVzb3VyY2VHcm91cHMvd3JpdGVcIixcbiAgICAgICAgICB9LFxuICAgICAgICBdLFxuICAgICAgfSxcbiAgICAgIGFjdGlvbnM6IHtcbiAgICAgICAgYWN0aW9uR3JvdXBzOiBbXG4gICAgICAgICAge1xuICAgICAgICAgICAgYWN0aW9uR3JvdXBJZDogYWN0aW9uR3JvdXAuaWQsXG4gICAgICAgICAgfSxcbiAgICAgICAgXSxcbiAgICAgIH0sXG4gICAgICB0YWdzOiB7XG4gICAgICAgIGVudmlyb25tZW50OiBcImV4YW1wbGVcIixcbiAgICAgIH0sXG4gICAgfSk7XG4gIH1cbn1cblxuZGVzY3JpYmUoXCJBY3Rpdml0eUxvZ0FsZXJ0IEludGVncmF0aW9uIFRlc3RcIiwgKCkgPT4ge1xuICBpdChcInNob3VsZCBkZXBsb3ksIHZhbGlkYXRlIGlkZW1wb3RlbmN5LCBhbmQgY2xlYW51cCBhY3Rpdml0eSBsb2cgYWxlcnQgcmVzb3VyY2VzXCIsICgpID0+IHtcbiAgICBjb25zdCBhcHAgPSBUZXN0aW5nLmFwcCgpO1xuICAgIGNvbnN0IHN0YWNrID0gbmV3IEFjdGl2aXR5TG9nQWxlcnRFeGFtcGxlU3RhY2soXG4gICAgICBhcHAsXG4gICAgICBcInRlc3QtYWN0aXZpdHlsb2dhbGVydFwiLFxuICAgICk7XG4gICAgY29uc3Qgc3ludGhlc2l6ZWQgPSBUZXN0aW5nLmZ1bGxTeW50aChzdGFjayk7XG5cbiAgICAvLyBUaGlzIHdpbGw6XG4gICAgLy8gMS4gUnVuIHRlcnJhZm9ybSBhcHBseSB0byBkZXBsb3kgcmVzb3VyY2VzXG4gICAgLy8gMi4gUnVuIHRlcnJhZm9ybSBwbGFuIHRvIGNoZWNrIGlkZW1wb3RlbmN5IChubyBjaGFuZ2VzIGV4cGVjdGVkKVxuICAgIC8vIDMuIFJ1biB0ZXJyYWZvcm0gZGVzdHJveSB0byBjbGVhbnVwIHJlc291cmNlc1xuICAgIFRlcnJhZm9ybUFwcGx5Q2hlY2tBbmREZXN0cm95KHN5bnRoZXNpemVkKTtcbiAgfSwgNjAwMDAwKTsgLy8gMTAgbWludXRlIHRpbWVvdXQgZm9yIGRlcGxveW1lbnQgYW5kIGNsZWFudXBcbn0pO1xuIl19

package/lib/azure-activitylogalert/test/activity-log-alert.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive tests for the ActivityLogAlert implementation
+ *
+ * This test suite validates the ActivityLogAlert class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * condition filtering, category types, scope configurations, action group integration,
+ * property transformation, and resource creation.
+ */
+export {};