@microsoft/terraform-cdk-constructs 1.10.0 → 2.5.0

package/README.md

@@ -36,6 +36,7 @@ With AZAPI L2 Constructs, you get the following benefits:
 | [Virtual Machines](./src/azure-virtualmachine/README.md) | 2024-07-01, 2024-11-01, 2025-04-01 | ✅ Built-in | ✅ Available |
 | [AKS Clusters](./src/azure-aks/README.md) | 2025-05-01, 2025-07-01, 2025-08-01 | ✅ Built-in | ✅ Available |
 | [Virtual Machine Scale Sets](./src/azure-vmss/README.md) | 2025-01-02, 2025-02-01, 2025-04-01 | ✅ Built-in | ✅ Available |
+| [Static Web Apps](./src/azure-staticwebapp/README.md) | 2022-03-01, 2023-12-01, 2024-04-01 | ❌ Not yet | ✅ Available |
 
 ### Networking
 
@@ -55,6 +56,7 @@ With AZAPI L2 Constructs, you get the following benefits:
 | [Metric Alerts](./src/azure-metricalert/README.md) | 2018-03-01 | ✅ Available |
 | [Activity Log Alerts](./src/azure-activitylogalert/README.md) | 2020-10-01 | ✅ Available |
 | [Diagnostic Settings](./src/azure-diagnosticsettings/README.md) | 2016-09-01, 2021-05-01-preview | ✅ Available |
+| [Application Insights](./src/azure-applicationinsights/README.md) | 2020-02-02 | ✅ Available |
 
 ### Foundation
 
@@ -62,6 +64,19 @@ With AZAPI L2 Constructs, you get the following benefits:
 |---------|-------------|--------|
 | [Resource Groups](./src/azure-resourcegroup/README.md) | 2024-11-01, 2025-01-01, 2025-03-01 | ✅ Available |
 | [Storage Accounts](./src/azure-storageaccount/README.md) | 2023-01-01, 2023-05-01, 2024-01-01 | ✅ Available |
+| [Key Vaults](./src/azure-keyvault/README.md) | 2023-02-01, 2023-07-01, 2024-11-01 | ✅ Available |
+
+### Database
+
+| Service | API Versions | Status |
+|---------|-------------|--------|
+| [Cosmos DB Accounts](./src/azure-cosmosdb/README.md) | 2023-11-15, 2024-05-15, 2024-08-15 | ✅ Available |
+
+### Messaging & Integration
+
+| Service | API Versions | Status |
+|---------|-------------|--------|
+| [Event Hubs](./src/azure-eventhub/README.md) | 2021-11-01, 2024-01-01 | ✅ Available |
 
 ## Quick Example
 

package/docs/azure-api-version-update-pipeline.md

@@ -0,0 +1,271 @@
+# Design: Monthly Azure API Version Update Pipeline
+
+## Context
+
+This project maintains ~31 Azure AZAPI constructs, each with hand-curated `*-schemas.ts` files defining `VersionConfig[]` arrays for supported API versions. Today, discovering and adding new Azure API versions is entirely manual. This pipeline automates that process end-to-end: discover new stable versions monthly, generate accurate schema updates using AI, run tests, and create a PR.
+
+---
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Monthly Cron (15th of each month)                          │
+│  .github/workflows/azure-version-update.yml                 │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  Job 1: discover                                            │
+│  ├─ Scan src/azure-*/lib/*-schemas.ts for resource types    │
+│  ├─ Query ARM API for available stable versions             │
+│  ├─ Diff against known versions                             │
+│  └─ Output version-manifest.json                            │
+│                                                             │
+│  Job 2: generate (via GitHub Copilot Coding Agent)          │
+│  ├─ Create a GitHub Issue with version update instructions  │
+│  ├─ Assign to Copilot Coding Agent                          │
+│  ├─ Agent fetches Azure REST API specs from GitHub          │
+│  ├─ Agent generates new VersionConfig + ApiSchema entries   │
+│  ├─ Agent updates defaultVersion() in construct files       │
+│  ├─ Agent updates unit test version assertions              │
+│  └─ Agent creates a PR with all changes                     │
+│                                                             │
+│  Job 3: test (triggered by PR creation)                     │
+│  ├─ Existing build.yml runs on the PR                       │
+│  ├─ Unit tests via npx projen build                         │
+│  ├─ Integration tests (continue-on-error)                   │
+│  └─ Results visible on the PR                               │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Approach: GitHub Copilot Coding Agent
+
+Instead of writing custom code generation scripts that call Claude via GitHub Models API, we leverage the **GitHub Copilot Coding Agent** -- GitHub's built-in autonomous coding agent that can be assigned to issues and creates PRs autonomously.
+
+### Why Copilot Coding Agent?
+
+| Aspect | Custom Scripts + GitHub Models API | Copilot Coding Agent |
+|--------|-----------------------------------|----------------------|
+| Code generation | Custom TypeScript scripts with regex/template logic | Agent reads codebase, understands patterns, generates code |
+| Maintenance burden | Must maintain spec-mapping, prompt engineering, file insertion logic | Zero maintenance -- agent adapts to project changes |
+| Test execution | Custom workflow jobs for running tests | Agent can run tests itself and iterate on failures |
+| PR creation | peter-evans/create-pull-request | Agent creates PR natively |
+| Edge cases | Must handle every schema variation in code | Agent handles variations naturally via codebase understanding |
+| New secret required | GITHUB_MODELS_TOKEN (PAT with models:read) | None -- uses existing Copilot license |
+| Self-healing | Fails on unexpected schema patterns | Agent can read errors and fix its own code |
+
+### How It Works
+
+1. **Discovery script** (`scripts/azure-version-updater/discover.ts`) runs on a monthly cron and produces a `version-manifest.json` listing new API versions per construct
+2. **Workflow creates a GitHub Issue** with structured instructions for the Copilot Coding Agent, including:
+   - The version manifest (which constructs need updates, which new versions)
+   - Links to Azure REST API spec files on GitHub for each new version
+   - Instructions referencing the project's schema conventions and a reference file
+3. **Copilot Coding Agent is assigned** to the issue via `gh issue edit --add-assignee @copilot`
+4. **The agent autonomously**:
+   - Reads the existing schema files to understand the pattern
+   - Fetches Azure REST API specs to understand property changes
+   - Generates new `ApiSchema` and `VersionConfig` entries
+   - Updates `defaultVersion()` in construct files
+   - Updates unit tests
+   - Creates a PR
+5. **Existing build.yml** runs on the PR (unit tests, lint, build)
+6. **A separate integration test job** can be triggered on the PR
+
+---
+
+## Files to Create
+
+### 1. `scripts/azure-version-updater/discover.ts`
+
+**Purpose**: Scan constructs, query Azure ARM, produce a manifest of new versions.
+
+**Logic**:
+1. Glob `src/azure-*/lib/*-schemas.ts`
+2. For each file, regex-extract:
+   - Resource type constant: `export const \w+_TYPE\s*=\s*"(.+)"`
+   - Schema prefix: `export const (\w+)_TYPE`
+   - Known versions: all `version:\s*"(\d{4}-\d{2}-\d{2})"` strings
+3. Dedupe by namespace, batch ARM API calls:
+   `GET https://management.azure.com/providers/{namespace}?api-version=2024-09-01`
+4. For each resource type, filter to stable versions (no `-preview`), find versions newer than the latest known
+5. Write `version-manifest.json`:
+
+```json
+{
+  "updates": [
+    {
+      "schemaFile": "src/azure-resourcegroup/lib/resource-group-schemas.ts",
+      "constructFile": "src/azure-resourcegroup/lib/resource-group.ts",
+      "testFile": "src/azure-resourcegroup/test/resource-group.spec.ts",
+      "resourceType": "Microsoft.Resources/resourceGroups",
+      "namespace": "Microsoft.Resources",
+      "resourceTypeName": "resourceGroups",
+      "prefix": "RESOURCE_GROUP",
+      "knownVersions": ["2024-11-01", "2025-01-01", "2025-03-01"],
+      "newVersions": ["2025-05-01", "2025-07-01"],
+      "specUrls": {
+        "2025-05-01": "https://github.com/Azure/azure-rest-api-specs/tree/main/specification/resources/resource-manager/Microsoft.Resources/stable/2025-05-01",
+        "2025-07-01": "https://github.com/Azure/azure-rest-api-specs/tree/main/specification/resources/resource-manager/Microsoft.Resources/stable/2025-07-01"
+      }
+    }
+  ],
+  "summary": { "totalConstructs": 31, "constructsWithUpdates": 3 }
+}
+```
+
+### 2. `scripts/azure-version-updater/spec-mapping.ts`
+
+**Purpose**: Map Azure resource types to their REST API spec paths on GitHub.
+
+Contains:
+- `SPEC_PATH_MAP`: explicit mapping from resource type to spec directory path
+- Convention-based fallback for unmapped types
+- Helper to build spec URLs for the issue body
+
+### 3. `.github/workflows/azure-version-update.yml`
+
+**Purpose**: Monthly cron workflow that discovers versions and creates a Copilot Agent issue.
+
+```yaml
+name: azure-version-update
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "0 10 15 * *"  # 15th of month, 10:00 UTC
+
+jobs:
+  discover:
+    name: Discover New API Versions
+    runs-on: ubuntu-latest
+    environment: Build
+    permissions:
+      contents: read
+      id-token: write
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: "20.16.0" }
+      - uses: azure/login@v2
+        with:
+          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
+          client-id: ${{ secrets.AZURE_CLIENT_ID }}
+      - run: yarn install --check-files --frozen-lockfile
+      - name: Discover versions
+        id: discover
+        run: |
+          npx ts-node scripts/azure-version-updater/discover.ts > version-manifest.json
+          echo "has_updates=$(jq 'if .updates | length > 0 then "true" else "false" end' -r version-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: Create Copilot Agent issue
+        if: steps.discover.outputs.has_updates == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.PROJEN_GITHUB_TOKEN }}
+        run: |
+          npx ts-node scripts/azure-version-updater/create-issue.ts version-manifest.json | \
+            gh issue create \
+              --title "feat(azure): update API versions to latest stable ($(date +%Y-%m))" \
+              --body-file - \
+              --assignee copilot
+```
+
+### 4. `scripts/azure-version-updater/create-issue.ts`
+
+**Purpose**: Generate a well-structured GitHub Issue body that gives the Copilot Coding Agent all the context it needs.
+
+The issue body will include:
+- Summary of which constructs have new versions
+- For each construct:
+  - The schema file path
+  - The construct file path
+  - The test file path
+  - Current latest version and new version(s)
+  - Link to Azure REST API spec for the new version
+- Reference to the project conventions:
+  - "See `src/azure-resourcegroup/lib/resource-group-schemas.ts` as a reference for the schema pattern"
+  - "See `src/core-azure/lib/version-manager/interfaces/version-interfaces.ts` for the interfaces"
+- Explicit instructions:
+  - "For each new version, create a new `ApiSchema` const and `VersionConfig` const following the naming convention `{PREFIX}_SCHEMA_{VERSION_UNDERSCORED}`"
+  - "Add the new version to the `ALL_*_VERSIONS` array"
+  - "Update `defaultVersion()` to return the newest version"
+  - "Update unit tests to include the new version in version list assertions and update latest version expectations"
+  - "Fetch the Azure REST API OpenAPI spec to identify any new or changed properties"
+  - "Run `npm test` to verify unit tests pass"
+
+### 5. `.github/copilot-instructions.md` (update)
+
+Add project-specific instructions for the Copilot Agent to understand the schema conventions, file structure, and coding patterns. This file is automatically read by Copilot when working on the repo.
+
+---
+
+## Secrets Required
+
+| Secret | Purpose | Status |
+|--------|---------|--------|
+| `AZURE_SUBSCRIPTION_ID` | ARM API calls for version discovery | Already exists |
+| `AZURE_TENANT_ID` | Azure OIDC auth | Already exists |
+| `AZURE_CLIENT_ID` | Azure OIDC auth | Already exists |
+| `PROJEN_GITHUB_TOKEN` | Issue creation + Copilot Agent trigger | Already exists |
+
+No new secrets needed -- the Copilot Coding Agent uses the organization's existing Copilot license.
+
+---
+
+## Copilot Agent Issue Template
+
+```markdown
+## Azure API Version Update - {month} {year}
+
+The following constructs have new stable Azure API versions available.
+
+### Instructions
+
+For each construct listed below:
+1. Open the Azure REST API spec link to understand property changes
+2. Read the existing schema file to understand the pattern
+3. Create new `ApiSchema` and `VersionConfig` entries following the exact naming convention
+4. Add the new entries to the `ALL_*_VERSIONS` array
+5. Update `defaultVersion()` in the construct file to return the newest version
+6. Update unit tests to include the new version
+7. Run `npm test` to verify
+
+**Reference files:**
+- Schema pattern: `src/azure-resourcegroup/lib/resource-group-schemas.ts`
+- Interfaces: `src/core-azure/lib/version-manager/interfaces/version-interfaces.ts`
+
+### Updates
+
+#### 1. Resource Group (`Microsoft.Resources/resourceGroups`)
+- **Schema file**: `src/azure-resourcegroup/lib/resource-group-schemas.ts`
+- **Construct file**: `src/azure-resourcegroup/lib/resource-group.ts`
+- **Test file**: `src/azure-resourcegroup/test/resource-group.spec.ts`
+- **Current latest**: `2025-03-01`
+- **New versions**: `2025-05-01`
+- **Azure REST API spec**: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/resources/resource-manager/Microsoft.Resources/stable/2025-05-01
+
+#### 2. ...
+```
+
+---
+
+## Verification
+
+1. **Local testing of discover.ts**: `az login && npx ts-node scripts/azure-version-updater/discover.ts`
+2. **Issue creation dry run**: Review generated issue body before assigning to Copilot
+3. **Copilot Agent behavior**: Monitor the agent's PR for correctness
+4. **CI validation**: Existing build.yml runs unit tests on the PR
+5. **Manual review**: A human reviews the PR before merging
+
+---
+
+## Implementation Order
+
+1. `scripts/azure-version-updater/spec-mapping.ts` -- resource type to spec path mapping
+2. `scripts/azure-version-updater/discover.ts` -- version discovery
+3. `scripts/azure-version-updater/create-issue.ts` -- issue body generation
+4. `.github/workflows/azure-version-update.yml` -- workflow
+5. `.github/copilot-instructions.md` -- Copilot Agent context
+6. Test locally with `workflow_dispatch`

package/lib/azure-actiongroup/lib/action-group.d.ts

@@ -15,7 +15,7 @@
  * - Full JSII compliance for multi-language support
  * - Support for multiple receiver types (email, SMS, webhook, etc.)
  */
-import * as cdktf from "cdktf";
+import * as cdktn from "cdktn";
 import { Construct } from "constructs";
 import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
 import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
@@ -257,8 +257,8 @@ export declare class ActionGroup extends AzapiResource {
      * The input properties for this Action Group instance
      */
     readonly props: ActionGroupProps;
-    readonly idOutput: cdktf.TerraformOutput;
-    readonly nameOutput: cdktf.TerraformOutput;
+    readonly idOutput: cdktn.TerraformOutput;
+    readonly nameOutput: cdktn.TerraformOutput;
     /**
      * Creates a new Azure Action Group using the AzapiResource framework
      *

package/lib/azure-actiongroup/lib/action-group.js

@@ -20,7 +20,7 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
  * - Full JSII compliance for multi-language support
  * - Support for multiple receiver types (email, SMS, webhook, etc.)
  */
-const cdktf = require("cdktf");
+const cdktn = require("cdktn");
 const action_group_schemas_1 = require("./action-group-schemas");
 const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
 /**
@@ -87,11 +87,11 @@ class ActionGroup extends azapi_resource_1.AzapiResource {
         this.props = props;
         // Extract properties from the AZAPI resource outputs using Terraform interpolation
         // Create Terraform outputs for easy access and referencing from other resources
-        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+        this.idOutput = new cdktn.TerraformOutput(this, "id", {
             value: this.id,
             description: "The ID of the Action Group",
         });
-        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+        this.nameOutput = new cdktn.TerraformOutput(this, "name", {
             value: `\${${this.terraformResource.fqn}.name}`,
             description: "The name of the Action Group",
         });
@@ -168,8 +168,8 @@ class ActionGroup extends azapi_resource_1.AzapiResource {
 }
 exports.ActionGroup = ActionGroup;
 _a = JSII_RTTI_SYMBOL_1;
-ActionGroup[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ActionGroup", version: "1.10.0" };
+ActionGroup[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ActionGroup", version: "2.5.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(action_group_schemas_1.ACTION_GROUP_TYPE, action_group_schemas_1.ALL_ACTION_GROUP_VERSIONS);
 })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-group.js","sourceRoot":"","sources":["../../../src/azure-actiongroup/lib/action-group.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Action Group implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Action Groups\n * that automatically handles version management, schema validation, and property\n * transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2021-09-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 multiple receiver types (email, SMS, webhook, etc.)\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_ACTION_GROUP_VERSIONS,\n  ACTION_GROUP_TYPE,\n} from \"./action-group-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Email receiver configuration\n */\nexport interface EmailReceiver {\n  /**\n   * The name of the email receiver\n   */\n  readonly name: string;\n\n  /**\n   * The email address to send notifications to\n   */\n  readonly emailAddress: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * SMS receiver configuration\n */\nexport interface SmsReceiver {\n  /**\n   * The name of the SMS receiver\n   */\n  readonly name: string;\n\n  /**\n   * The country code (e.g., \"1\" for US)\n   */\n  readonly countryCode: string;\n\n  /**\n   * The phone number to send SMS to\n   */\n  readonly phoneNumber: string;\n}\n\n/**\n * Webhook receiver configuration\n */\nexport interface WebhookReceiver {\n  /**\n   * The name of the webhook receiver\n   */\n  readonly name: string;\n\n  /**\n   * The service URI to send webhooks to\n   */\n  readonly serviceUri: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Azure Function receiver configuration\n */\nexport interface AzureFunctionReceiver {\n  /**\n   * The name of the Azure Function receiver\n   */\n  readonly name: string;\n\n  /**\n   * The function app resource ID\n   */\n  readonly functionAppResourceId: string;\n\n  /**\n   * The function name\n   */\n  readonly functionName: string;\n\n  /**\n   * The HTTP trigger URL\n   */\n  readonly httpTriggerUrl: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Logic App receiver configuration\n */\nexport interface LogicAppReceiver {\n  /**\n   * The name of the Logic App receiver\n   */\n  readonly name: string;\n\n  /**\n   * The Logic App resource ID\n   */\n  readonly resourceId: string;\n\n  /**\n   * The callback URL\n   */\n  readonly callbackUrl: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Voice receiver configuration\n */\nexport interface VoiceReceiver {\n  /**\n   * The name of the voice receiver\n   */\n  readonly name: string;\n\n  /**\n   * The country code (e.g., \"1\" for US)\n   */\n  readonly countryCode: string;\n\n  /**\n   * The phone number to call\n   */\n  readonly phoneNumber: string;\n}\n\n/**\n * Properties for the unified Azure Action Group\n *\n * Extends AzapiResourceProps with Action Group specific properties\n */\nexport interface ActionGroupProps extends AzapiResourceProps {\n  /**\n   * Short name for SMS notifications (max 12 chars)\n   * @example \"OpsTeam\"\n   */\n  readonly groupShortName: string;\n\n  /**\n   * Whether the action group is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Email notification receivers\n   */\n  readonly emailReceivers?: EmailReceiver[];\n\n  /**\n   * SMS notification receivers\n   */\n  readonly smsReceivers?: SmsReceiver[];\n\n  /**\n   * Webhook notification receivers\n   */\n  readonly webhookReceivers?: WebhookReceiver[];\n\n  /**\n   * Azure Function receivers\n   */\n  readonly azureFunctionReceivers?: AzureFunctionReceiver[];\n\n  /**\n   * Logic App receivers\n   */\n  readonly logicAppReceivers?: LogicAppReceiver[];\n\n  /**\n   * Voice call receivers\n   */\n  readonly voiceReceivers?: VoiceReceiver[];\n\n  /**\n   * Resource group ID where the action group will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Action Group properties for the request body\n */\nexport interface ActionGroupBodyProperties {\n  readonly groupShortName: string;\n  readonly enabled: boolean;\n  readonly emailReceivers?: EmailReceiver[];\n  readonly smsReceivers?: SmsReceiver[];\n  readonly webhookReceivers?: WebhookReceiver[];\n  readonly azureFunctionReceivers?: AzureFunctionReceiver[];\n  readonly logicAppReceivers?: LogicAppReceiver[];\n  readonly voiceReceivers?: VoiceReceiver[];\n}\n\n/**\n * The resource body interface for Azure Action Group API calls\n */\nexport interface ActionGroupBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly properties: ActionGroupBodyProperties;\n}\n\n/**\n * Unified Azure Action Group 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 * Action Groups serve as the central notification hub for Azure Monitor alerts, supporting\n * multiple receiver types including email, SMS, webhook, Azure Functions, Logic Apps, and voice calls.\n *\n * @example\n * // Basic action group with email notifications:\n * const actionGroup = new ActionGroup(this, \"ops-team\", {\n *   name: \"ops-action-group\",\n *   groupShortName: \"OpsTeam\",\n *   resourceGroupId: resourceGroup.id,\n *   emailReceivers: [{\n *     name: \"ops-email\",\n *     emailAddress: \"ops@company.com\",\n *     useCommonAlertSchema: true\n *   }]\n * });\n *\n * @example\n * // Action group with multiple receiver types:\n * const actionGroup = new ActionGroup(this, \"critical-alerts\", {\n *   name: \"critical-action-group\",\n *   groupShortName: \"Critical\",\n *   resourceGroupId: resourceGroup.id,\n *   emailReceivers: [{\n *     name: \"oncall-email\",\n *     emailAddress: \"oncall@company.com\",\n *     useCommonAlertSchema: true\n *   }],\n *   smsReceivers: [{\n *     name: \"oncall-sms\",\n *     countryCode: \"1\",\n *     phoneNumber: \"5551234567\"\n *   }],\n *   webhookReceivers: [{\n *     name: \"pagerduty-webhook\",\n *     serviceUri: \"https://events.pagerduty.com/...\",\n *     useCommonAlertSchema: true\n *   }]\n * });\n *\n * @stability stable\n */\nexport class ActionGroup extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(ACTION_GROUP_TYPE, ALL_ACTION_GROUP_VERSIONS);\n  }\n\n  /**\n   * The input properties for this Action Group instance\n   */\n  public readonly props: ActionGroupProps;\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\n  /**\n   * Creates a new Azure Action Group 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 Action Group\n   */\n  constructor(scope: Construct, id: string, props: ActionGroupProps) {\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\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 Action Group\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Action Group\",\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 \"2021-09-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Action Groups\n   */\n  protected resourceType(): string {\n    return ACTION_GROUP_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 ActionGroupProps;\n    return {\n      location: \"Global\",\n      tags: typedProps.tags || {},\n      properties: {\n        groupShortName: typedProps.groupShortName,\n        enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,\n        emailReceivers: typedProps.emailReceivers || [],\n        smsReceivers: typedProps.smsReceivers || [],\n        webhookReceivers: typedProps.webhookReceivers || [],\n        azureFunctionReceivers: typedProps.azureFunctionReceivers || [],\n        logicAppReceivers: typedProps.logicAppReceivers || [],\n        voiceReceivers: typedProps.voiceReceivers || [],\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR ACTION GROUP OPERATIONS\n  // =============================================================================\n\n  /**\n   * Add a tag to the Action Group\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 Action Group\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-group.js","sourceRoot":"","sources":["../../../src/azure-actiongroup/lib/action-group.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Action Group implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Action Groups\n * that automatically handles version management, schema validation, and property\n * transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2021-09-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 multiple receiver types (email, SMS, webhook, etc.)\n */\n\nimport * as cdktn from \"cdktn\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_ACTION_GROUP_VERSIONS,\n  ACTION_GROUP_TYPE,\n} from \"./action-group-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Email receiver configuration\n */\nexport interface EmailReceiver {\n  /**\n   * The name of the email receiver\n   */\n  readonly name: string;\n\n  /**\n   * The email address to send notifications to\n   */\n  readonly emailAddress: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * SMS receiver configuration\n */\nexport interface SmsReceiver {\n  /**\n   * The name of the SMS receiver\n   */\n  readonly name: string;\n\n  /**\n   * The country code (e.g., \"1\" for US)\n   */\n  readonly countryCode: string;\n\n  /**\n   * The phone number to send SMS to\n   */\n  readonly phoneNumber: string;\n}\n\n/**\n * Webhook receiver configuration\n */\nexport interface WebhookReceiver {\n  /**\n   * The name of the webhook receiver\n   */\n  readonly name: string;\n\n  /**\n   * The service URI to send webhooks to\n   */\n  readonly serviceUri: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Azure Function receiver configuration\n */\nexport interface AzureFunctionReceiver {\n  /**\n   * The name of the Azure Function receiver\n   */\n  readonly name: string;\n\n  /**\n   * The function app resource ID\n   */\n  readonly functionAppResourceId: string;\n\n  /**\n   * The function name\n   */\n  readonly functionName: string;\n\n  /**\n   * The HTTP trigger URL\n   */\n  readonly httpTriggerUrl: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Logic App receiver configuration\n */\nexport interface LogicAppReceiver {\n  /**\n   * The name of the Logic App receiver\n   */\n  readonly name: string;\n\n  /**\n   * The Logic App resource ID\n   */\n  readonly resourceId: string;\n\n  /**\n   * The callback URL\n   */\n  readonly callbackUrl: string;\n\n  /**\n   * Whether to use common alert schema\n   * @defaultValue false\n   */\n  readonly useCommonAlertSchema?: boolean;\n}\n\n/**\n * Voice receiver configuration\n */\nexport interface VoiceReceiver {\n  /**\n   * The name of the voice receiver\n   */\n  readonly name: string;\n\n  /**\n   * The country code (e.g., \"1\" for US)\n   */\n  readonly countryCode: string;\n\n  /**\n   * The phone number to call\n   */\n  readonly phoneNumber: string;\n}\n\n/**\n * Properties for the unified Azure Action Group\n *\n * Extends AzapiResourceProps with Action Group specific properties\n */\nexport interface ActionGroupProps extends AzapiResourceProps {\n  /**\n   * Short name for SMS notifications (max 12 chars)\n   * @example \"OpsTeam\"\n   */\n  readonly groupShortName: string;\n\n  /**\n   * Whether the action group is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Email notification receivers\n   */\n  readonly emailReceivers?: EmailReceiver[];\n\n  /**\n   * SMS notification receivers\n   */\n  readonly smsReceivers?: SmsReceiver[];\n\n  /**\n   * Webhook notification receivers\n   */\n  readonly webhookReceivers?: WebhookReceiver[];\n\n  /**\n   * Azure Function receivers\n   */\n  readonly azureFunctionReceivers?: AzureFunctionReceiver[];\n\n  /**\n   * Logic App receivers\n   */\n  readonly logicAppReceivers?: LogicAppReceiver[];\n\n  /**\n   * Voice call receivers\n   */\n  readonly voiceReceivers?: VoiceReceiver[];\n\n  /**\n   * Resource group ID where the action group will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Action Group properties for the request body\n */\nexport interface ActionGroupBodyProperties {\n  readonly groupShortName: string;\n  readonly enabled: boolean;\n  readonly emailReceivers?: EmailReceiver[];\n  readonly smsReceivers?: SmsReceiver[];\n  readonly webhookReceivers?: WebhookReceiver[];\n  readonly azureFunctionReceivers?: AzureFunctionReceiver[];\n  readonly logicAppReceivers?: LogicAppReceiver[];\n  readonly voiceReceivers?: VoiceReceiver[];\n}\n\n/**\n * The resource body interface for Azure Action Group API calls\n */\nexport interface ActionGroupBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly properties: ActionGroupBodyProperties;\n}\n\n/**\n * Unified Azure Action Group 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 * Action Groups serve as the central notification hub for Azure Monitor alerts, supporting\n * multiple receiver types including email, SMS, webhook, Azure Functions, Logic Apps, and voice calls.\n *\n * @example\n * // Basic action group with email notifications:\n * const actionGroup = new ActionGroup(this, \"ops-team\", {\n *   name: \"ops-action-group\",\n *   groupShortName: \"OpsTeam\",\n *   resourceGroupId: resourceGroup.id,\n *   emailReceivers: [{\n *     name: \"ops-email\",\n *     emailAddress: \"ops@company.com\",\n *     useCommonAlertSchema: true\n *   }]\n * });\n *\n * @example\n * // Action group with multiple receiver types:\n * const actionGroup = new ActionGroup(this, \"critical-alerts\", {\n *   name: \"critical-action-group\",\n *   groupShortName: \"Critical\",\n *   resourceGroupId: resourceGroup.id,\n *   emailReceivers: [{\n *     name: \"oncall-email\",\n *     emailAddress: \"oncall@company.com\",\n *     useCommonAlertSchema: true\n *   }],\n *   smsReceivers: [{\n *     name: \"oncall-sms\",\n *     countryCode: \"1\",\n *     phoneNumber: \"5551234567\"\n *   }],\n *   webhookReceivers: [{\n *     name: \"pagerduty-webhook\",\n *     serviceUri: \"https://events.pagerduty.com/...\",\n *     useCommonAlertSchema: true\n *   }]\n * });\n *\n * @stability stable\n */\nexport class ActionGroup extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(ACTION_GROUP_TYPE, ALL_ACTION_GROUP_VERSIONS);\n  }\n\n  /**\n   * The input properties for this Action Group instance\n   */\n  public readonly props: ActionGroupProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktn.TerraformOutput;\n  public readonly nameOutput: cdktn.TerraformOutput;\n\n  // Public properties\n\n  /**\n   * Creates a new Azure Action Group 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 Action Group\n   */\n  constructor(scope: Construct, id: string, props: ActionGroupProps) {\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktn.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Action Group\",\n    });\n\n    this.nameOutput = new cdktn.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Action Group\",\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 \"2021-09-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Action Groups\n   */\n  protected resourceType(): string {\n    return ACTION_GROUP_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 ActionGroupProps;\n    return {\n      location: \"Global\",\n      tags: typedProps.tags || {},\n      properties: {\n        groupShortName: typedProps.groupShortName,\n        enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,\n        emailReceivers: typedProps.emailReceivers || [],\n        smsReceivers: typedProps.smsReceivers || [],\n        webhookReceivers: typedProps.webhookReceivers || [],\n        azureFunctionReceivers: typedProps.azureFunctionReceivers || [],\n        logicAppReceivers: typedProps.logicAppReceivers || [],\n        voiceReceivers: typedProps.voiceReceivers || [],\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR ACTION GROUP OPERATIONS\n  // =============================================================================\n\n  /**\n   * Add a tag to the Action Group\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 Action Group\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-actiongroup/test/action-group.integ.d.ts

@@ -6,4 +6,4 @@
  *
  * Run with: npm run integration:nostream
  */
-import "cdktf/lib/testing/adapters/jest";
+import "cdktn/lib/testing/adapters/jest";

package/lib/azure-actiongroup/test/action-group.integ.js

@@ -8,8 +8,8 @@
  * Run with: npm run integration:nostream
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const cdktf_1 = require("cdktf");
-require("cdktf/lib/testing/adapters/jest");
+const cdktn_1 = require("cdktn");
+require("cdktn/lib/testing/adapters/jest");
 const azure_resourcegroup_1 = require("../../azure-resourcegroup");
 const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
 const testing_1 = require("../../testing");
@@ -66,9 +66,9 @@ class ActionGroupExampleStack extends testing_1.BaseTestStack {
 }
 describe("ActionGroup Integration Test", () => {
     it("should deploy, validate idempotency, and cleanup action group resources", () => {
-        const app = cdktf_1.Testing.app();
+        const app = cdktn_1.Testing.app();
         const stack = new ActionGroupExampleStack(app, "test-actiongroup");
-        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        const synthesized = cdktn_1.Testing.fullSynth(stack);
         // This will:
         // 1. Run terraform apply to deploy resources
         // 2. Run terraform plan to check idempotency (no changes expected)
@@ -76,4 +76,4 @@ describe("ActionGroup Integration Test", () => {
         (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
     }, 600000); // 10 minute timeout for deployment and cleanup
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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