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

package/README.md

@@ -1,32 +1,126 @@
-# Terraform-Azure-CDK-Modules
+# Azure Terraform CDK Constructs
+Welcome to the Azure Terraform CDK Constructs project! This library offers a comprehensive suite of L2 Constructs designed to simplify and enhance the experience of building and managing Azure infrastructure with the Cloud Development Kit for Terraform (CDKTF).
 
-This repository contains code for building infrastructure using Terraform Azure CDK modules.
+## Benefits of Using L2 Constructs
 
+With L2 Constructs, you get the following benefits:
 
+- **Abstraction**: Higher-level abstractions over Azure resources make your infrastructure code more declarative and easier to understand.
+- **Reusability**: Encapsulate common patterns and best practices in your infrastructure code, promoting reusability across different projects and teams.
+- **Rapid Development**: Accelerate your cloud development process with pre-built constructs that have been tested for common use cases, allowing you to focus on your unique application logic.
+- **Direct IDE Integration**: Access detailed documentation directly within your Integrated Development Environment (IDE), streamlining your development workflow: ![alt text](./docs/images/ide-documentation.png)
 
-## Using the Libraries
 
-This project includes several libraries for building infrastructure using Azure modules. Here are some examples of how to use them:
+## Quick Example
 
-### Example 1: Creating a Virtual Machine
+This is a quick example that showcases the simplicity and power of L2 Constructs. We'll create a storage account, add a container to it, and then upload a blob—all with a few lines of intuitive, object-oriented code:
 
 ```typescript
-import { VirtualMachine } from '@my-awesome-infra/virtual-machine';
-
-const vm = new VirtualMachine({
-  name: 'my-vm',
-  location: 'eastus',
-  resourceGroup: 'my-resource-group',
-  size: 'Standard_D2s_v3',
-  osDisk: {
-    storageAccountType: 'Standard_LRS',
-    diskSizeGB: 128,
-  },
-  adminUsername: 'admin',
-  adminPassword: 'password',
+
+// Create a new instance of a storage account as an object
+const sa = new azcdk.azure_storageaccount.Account(stack, "storageaccount", {
+  name: "testStorageAccount",
+  location: "eastus",
 });
+
+// Add a container to the storage account by calling a method on the storage account object
+const container = sa.addContainer("testcontainer");
+
+// Add a blob to the container by calling a method on the container object
+// The path "../../../test.txt" points to the source file to be uploaded as a blob
+container.addBlob("testblob.txt", "../../../test.txt");
+```
+
+
+
+## Getting Started
+
+This guide will walk you through the process of using the Azure L2 Constructs to define and provision infrastructure on Azure. 
+
+### Prerequisites
+Make sure you have Node.js and npm installed on your machine. These will be used to install the CDK for Terraform and Azure provider packages.
+
+### Installation
+
+First, install the CDK for Terraform CLI globally using npm:
+
+```sh
+npm install -g cdktf-cli
+```
+
+Next, initialize a new CDK for Terraform project with TypeScript template:
+```sh
+cdktf init --template="TypeScript" --local
+```
+Install the AzureRM provider for CDKTF:
+
+```sh
+npm install @cdktf/provider-azurerm
 ```
 
+Then, add the Microsoft Terraform CDK constructs for Azure:
+
+```sh
+npm install @micrsoft/terraform-cdk-constructs
+
+```
+
+
+### Example 1: Creating a Storage Account
+Now let's create a simple Azure storage account. The following TypeScript snippet defines a storage account resource using the CDKTF:
+
+```typescript
+// Import necessary modules and classes
+import * as azcdk from "@microsoft/terraform-cdk-constructs";
+import { Construct } from 'constructs';
+import { App, TerraformStack } from 'cdktf';
+import { AzurermProvider } from "@cdktf/provider-azurerm/lib/provider";
+
+// Define a new Terraform stack
+class AzureAppInfra extends TerraformStack {
+ constructor(scope: Construct, name: string) {
+   super(scope, name);
+
+   // Initialize Azure provider
+   new AzurermProvider(this, "azureFeature", { features: {} });
+
+   // Create a new Azure storage account with the specified name and location
+   new azcdk.azure_storageaccount.Account(this, "storageaccount", {
+     name: "test42348808",
+     location: "eastus",
+   });
+ }
+}
+
+// Initialize the CDK app and synthesize Terraform configurations
+const app = new App();
+new AzureAppInfra(app, 'cdk');
+app.synth();
+```
+After defining your infrastructure, generate the Terraform configuration files:
+```sh
+cdktf synth
+```
+Finally, deploy your infrastructure to Azure:
+
+```sh
+cdktf deploy
+```
+## Supported Languages
+
+Currently, our CDK L2 constructs are available in the following languages:
+
+| Language   | Status       |
+|------------|--------------|
+| TypeScript | Available    |
+| Python     | Coming soon  |
+| Java       | Coming soon  |
+| Go         | Coming soon  |
+| C#         | Coming soon  |
+
+Stay tuned for updates as we work to expand support to other popular programming languages!
+
+
 ## Contributing
 
 This project welcomes contributions and suggestions.  Most contributions require you to agree to a

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

@@ -6,5 +6,44 @@ export declare class ActionGroup extends AzureResource {
     readonly props: model.ActionGroupProps;
     resourceGroup: ResourceGroup;
     id: string;
+    /**
+     * Manages an Azure Monitor Action Group, which is used to trigger actions or notifications based on alerts or conditions met within Azure Monitor.
+     *
+     * An Action Group in Azure Monitor defines a collection of individual actions that are triggered when the conditions of an associated alert rule are met. Actions can include sending emails, triggering Azure Functions, calling webhooks, and more. This class allows for configuring and managing these actions, making it essential for setting up comprehensive monitoring and response systems in Azure applications.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Action Group.
+     * @param props - Configuration properties for the Action Group. These properties may include:
+     *                - `name`: The name of the Action Group.
+     *                - `resourceGroup`: The resource group under which the Action Group is created.
+     *                - `shortName`: A shorter name for the Action Group used in notifications.
+     *                - `enabled`: Specifies if the Action Group is active. Defaults to true.
+     *                - `location`: The Azure region where the Action Group is hosted. Defaults to global.
+     *                - `tags`: A dictionary of tags to apply to the Action Group for resource management.
+     *                - Receivers: Configurations for various types of notifications (e.g., email, SMS, webhook).
+     *
+     * Example usage:
+     * ```typescript
+     * const actionGroup = new ActionGroup(this, 'myActionGroup', {
+     *   name: 'criticalAlertsGroup',
+     *   resourceGroup: myResourceGroup,
+     *   shortName: 'Alerts',
+     *   location: 'East US',
+     *   emailReceivers: [{
+     *     name: 'admin',
+     *     emailAddress: 'admin@example.com'
+     *   }],
+     *   smsReceivers: [{
+     *     name: 'adminSms',
+     *     countryCode: '1',
+     *     phoneNumber: '5551234567'
+     *   }],
+     *   tags: {
+     *     environment: 'production'
+     *   }
+     * });
+     * ```
+     * This setup creates an Action Group that sends email and SMS notifications when triggered by an alert.
+     */
     constructor(scope: Construct, id: string, props: model.ActionGroupProps);
 }

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

@@ -6,6 +6,45 @@ const cdktf = require("cdktf");
 const lib_1 = require("../../core-azure/lib");
 const model = require("../model");
 class ActionGroup extends lib_1.AzureResource {
+    /**
+     * Manages an Azure Monitor Action Group, which is used to trigger actions or notifications based on alerts or conditions met within Azure Monitor.
+     *
+     * An Action Group in Azure Monitor defines a collection of individual actions that are triggered when the conditions of an associated alert rule are met. Actions can include sending emails, triggering Azure Functions, calling webhooks, and more. This class allows for configuring and managing these actions, making it essential for setting up comprehensive monitoring and response systems in Azure applications.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Action Group.
+     * @param props - Configuration properties for the Action Group. These properties may include:
+     *                - `name`: The name of the Action Group.
+     *                - `resourceGroup`: The resource group under which the Action Group is created.
+     *                - `shortName`: A shorter name for the Action Group used in notifications.
+     *                - `enabled`: Specifies if the Action Group is active. Defaults to true.
+     *                - `location`: The Azure region where the Action Group is hosted. Defaults to global.
+     *                - `tags`: A dictionary of tags to apply to the Action Group for resource management.
+     *                - Receivers: Configurations for various types of notifications (e.g., email, SMS, webhook).
+     *
+     * Example usage:
+     * ```typescript
+     * const actionGroup = new ActionGroup(this, 'myActionGroup', {
+     *   name: 'criticalAlertsGroup',
+     *   resourceGroup: myResourceGroup,
+     *   shortName: 'Alerts',
+     *   location: 'East US',
+     *   emailReceivers: [{
+     *     name: 'admin',
+     *     emailAddress: 'admin@example.com'
+     *   }],
+     *   smsReceivers: [{
+     *     name: 'adminSms',
+     *     countryCode: '1',
+     *     phoneNumber: '5551234567'
+     *   }],
+     *   tags: {
+     *     environment: 'production'
+     *   }
+     * });
+     * ```
+     * This setup creates an Action Group that sends email and SMS notifications when triggered by an alert.
+     */
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
@@ -43,4 +82,4 @@ class ActionGroup extends lib_1.AzureResource {
     }
 }
 exports.ActionGroup = ActionGroup;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uZ3JvdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtYWN0aW9uZ3JvdXAvbGliL2FjdGlvbmdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJGQUFzRjtBQUV0RiwrQkFBK0I7QUFFL0IsOENBQXFEO0FBQ3JELGtDQUFrQztBQUVsQyxNQUFhLFdBQVksU0FBUSxtQkFBYTtJQUs1QyxZQUFZLEtBQWdCLEVBQUUsRUFBVSxFQUFFLEtBQTZCO1FBQ3JFLEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUMsYUFBYSxDQUFDO1FBRXpDOztXQUVHO1FBQ0gsTUFBTSxRQUFRLEdBQUc7WUFDZixPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sSUFBSSxJQUFJO1lBQzlCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUSxJQUFJLFFBQVE7WUFDcEMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLElBQUksRUFBRTtTQUN2QixDQUFDO1FBRUYsdURBQXVEO1FBQ3ZELE1BQU0seUJBQXlCLEdBQUcsSUFBSSx5Q0FBa0IsQ0FDdEQsSUFBSSxFQUNKLGFBQWEsRUFDYjtZQUNFLEdBQUcsUUFBUTtZQUNYLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtZQUNoQixpQkFBaUIsRUFBRSxLQUFLLENBQUMsYUFBYSxDQUFDLElBQUk7WUFDM0MsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTO1lBQzFCLGVBQWUsRUFBRSxLQUFLLENBQUMsVUFBVSxDQUMvQixLQUFLLENBQUMsNENBQTRDLEVBQ2xELElBQUksQ0FDTCxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLENBQUM7WUFFOUIsYUFBYSxFQUFFLEtBQUssQ0FBQyxVQUFVLENBQzdCLEtBQUssQ0FBQywwQ0FBMEMsRUFDaEQsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxjQUFjLENBQUM7WUFFNUIsYUFBYSxFQUFFLEtBQUssQ0FBQyxVQUFVLENBQzdCLEtBQUssQ0FBQywwQ0FBMEMsRUFDaEQsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxjQUFjLENBQUM7WUFFNUIsV0FBVyxFQUFFLEtBQUssQ0FBQyxVQUFVLENBQzNCLEtBQUssQ0FBQyx3Q0FBd0MsRUFDOUMsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUM7WUFFMUIsZUFBZSxFQUFFLEtBQUssQ0FBQyxVQUFVLENBQy9CLEtBQUssQ0FBQyw0Q0FBNEMsRUFDbEQsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQztZQUU5QixnQkFBZ0IsRUFBRSxLQUFLLENBQUMsVUFBVSxDQUNoQyxLQUFLLENBQUMsNkNBQTZDLEVBQ25ELElBQUksQ0FDTCxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsaUJBQWlCLENBQUM7WUFFL0Isb0JBQW9CLEVBQUUsS0FBSyxDQUFDLFVBQVUsQ0FDcEMsS0FBSyxDQUFDLGlEQUFpRCxFQUN2RCxJQUFJLENBQ0wsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLHFCQUFxQixDQUFDO1lBRW5DLGdCQUFnQixFQUFFLEtBQUssQ0FBQyxVQUFVLENBQ2hDLEtBQUssQ0FBQyw2Q0FBNkMsRUFDbkQsSUFBSSxDQUNMLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQztTQUNoQyxDQUNGLENBQUM7UUFFRixvQkFBb0I7UUFDcEIsSUFBSSxDQUFDLEVBQUUsR0FBRyx5QkFBeUIsQ0FBQyxFQUFFLENBQUM7UUFFdkMsTUFBTSxpQ0FBaUMsR0FBRyxJQUFJLEtBQUssQ0FBQyxlQUFlLENBQ2pFLElBQUksRUFDSixJQUFJLEVBQ0o7WUFDRSxLQUFLLEVBQUUseUJBQXlCLENBQUMsRUFBRTtTQUNwQyxDQUNGLENBQUM7UUFFRixnSUFBZ0k7UUFDaEksaUNBQWlDLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUQsQ0FBQztDQUNGO0FBckZELGtDQXFGQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vbml0b3JBY3Rpb25Hcm91cCB9IGZyb20gXCJAY2RrdGYvcHJvdmlkZXItYXp1cmVybS9saWIvbW9uaXRvci1hY3Rpb24tZ3JvdXBcIjtcbmltcG9ydCB7IFJlc291cmNlR3JvdXAgfSBmcm9tIFwiQGNka3RmL3Byb3ZpZGVyLWF6dXJlcm0vbGliL3Jlc291cmNlLWdyb3VwXCI7XG5pbXBvcnQgKiBhcyBjZGt0ZiBmcm9tIFwiY2RrdGZcIjtcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5pbXBvcnQgeyBBenVyZVJlc291cmNlIH0gZnJvbSBcIi4uLy4uL2NvcmUtYXp1cmUvbGliXCI7XG5pbXBvcnQgKiBhcyBtb2RlbCBmcm9tIFwiLi4vbW9kZWxcIjtcblxuZXhwb3J0IGNsYXNzIEFjdGlvbkdyb3VwIGV4dGVuZHMgQXp1cmVSZXNvdXJjZSB7XG4gIHJlYWRvbmx5IHByb3BzOiBtb2RlbC5BY3Rpb25Hcm91cFByb3BzO1xuICBwdWJsaWMgcmVzb3VyY2VHcm91cDogUmVzb3VyY2VHcm91cDtcbiAgcHVibGljIGlkOiBzdHJpbmc7XG5cbiAgY29uc3RydWN0b3Ioc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZywgcHJvcHM6IG1vZGVsLkFjdGlvbkdyb3VwUHJvcHMpIHtcbiAgICBzdXBlcihzY29wZSwgaWQpO1xuXG4gICAgdGhpcy5wcm9wcyA9IHByb3BzO1xuICAgIHRoaXMucmVzb3VyY2VHcm91cCA9IHByb3BzLnJlc291cmNlR3JvdXA7XG5cbiAgICAvKipcbiAgICAgKiBEZWZpbmUgZGVmYXVsdCB2YWx1ZXMuXG4gICAgICovXG4gICAgY29uc3QgZGVmYXVsdHMgPSB7XG4gICAgICBlbmFibGVkOiBwcm9wcy5lbmFibGVkID8/IHRydWUsXG4gICAgICBsb2NhdGlvbjogcHJvcHMubG9jYXRpb24gPz8gXCJnbG9iYWxcIixcbiAgICAgIHRhZ3M6IHByb3BzLnRhZ3MgPz8ge30sXG4gICAgfTtcblxuICAgIC8vIENyZWF0ZSB0aGUgQWN0aW9uIEdyb3VwIHdpdGggdGhlIHByb3ZpZGVkIHByb3BlcnRpZXNcbiAgICBjb25zdCBhenVyZXJtTW9uaXRvckFjdGlvbkdyb3VwID0gbmV3IE1vbml0b3JBY3Rpb25Hcm91cChcbiAgICAgIHRoaXMsXG4gICAgICBcImFjdGlvbmdyb3VwXCIsXG4gICAgICB7XG4gICAgICAgIC4uLmRlZmF1bHRzLFxuICAgICAgICBuYW1lOiBwcm9wcy5uYW1lLFxuICAgICAgICByZXNvdXJjZUdyb3VwTmFtZTogcHJvcHMucmVzb3VyY2VHcm91cC5uYW1lLFxuICAgICAgICBzaG9ydE5hbWU6IHByb3BzLnNob3J0TmFtZSxcbiAgICAgICAgYXJtUm9sZVJlY2VpdmVyOiBjZGt0Zi5saXN0TWFwcGVyKFxuICAgICAgICAgIG1vZGVsLm1vbml0b3JBY3Rpb25Hcm91cEFybVJvbGVSZWNlaXZlclRvVGVycmFmb3JtLFxuICAgICAgICAgIHRydWUsXG4gICAgICAgICkodGhpcy5wcm9wcy5hcm1Sb2xlUmVjZWl2ZXJzKSxcblxuICAgICAgICBlbWFpbFJlY2VpdmVyOiBjZGt0Zi5saXN0TWFwcGVyKFxuICAgICAgICAgIG1vZGVsLm1vbml0b3JBY3Rpb25Hcm91cEVtYWlsUmVjZWl2ZXJUb1RlcnJhZm9ybSxcbiAgICAgICAgICB0cnVlLFxuICAgICAgICApKHRoaXMucHJvcHMuZW1haWxSZWNlaXZlcnMpLFxuXG4gICAgICAgIHZvaWNlUmVjZWl2ZXI6IGNka3RmLmxpc3RNYXBwZXIoXG4gICAgICAgICAgbW9kZWwubW9uaXRvckFjdGlvbkdyb3VwVm9pY2VSZWNlaXZlclRvVGVycmFmb3JtLFxuICAgICAgICAgIHRydWUsXG4gICAgICAgICkodGhpcy5wcm9wcy52b2ljZVJlY2VpdmVycyksXG5cbiAgICAgICAgc21zUmVjZWl2ZXI6IGNka3RmLmxpc3RNYXBwZXIoXG4gICAgICAgICAgbW9kZWwubW9uaXRvckFjdGlvbkdyb3VwU21zUmVjZWl2ZXJUb1RlcnJhZm9ybSxcbiAgICAgICAgICB0cnVlLFxuICAgICAgICApKHRoaXMucHJvcHMuc21zUmVjZWl2ZXJzKSxcblxuICAgICAgICB3ZWJob29rUmVjZWl2ZXI6IGNka3RmLmxpc3RNYXBwZXIoXG4gICAgICAgICAgbW9kZWwubW9uaXRvckFjdGlvbkdyb3VwV2ViaG9va1JlY2VpdmVyVG9UZXJyYWZvcm0sXG4gICAgICAgICAgdHJ1ZSxcbiAgICAgICAgKSh0aGlzLnByb3BzLndlYmhvb2tSZWNlaXZlcnMpLFxuXG4gICAgICAgIGV2ZW50SHViUmVjZWl2ZXI6IGNka3RmLmxpc3RNYXBwZXIoXG4gICAgICAgICAgbW9kZWwubW9uaXRvckFjdGlvbkdyb3VwRXZlbnRIdWJSZWNlaXZlclRvVGVycmFmb3JtLFxuICAgICAgICAgIHRydWUsXG4gICAgICAgICkodGhpcy5wcm9wcy5ldmVudEh1YlJlY2VpdmVycyksXG5cbiAgICAgICAgYXp1cmVBcHBQdXNoUmVjZWl2ZXI6IGNka3RmLmxpc3RNYXBwZXIoXG4gICAgICAgICAgbW9kZWwubW9uaXRvckFjdGlvbkdyb3VwQXp1cmVBcHBQdXNoUmVjZWl2ZXJUb1RlcnJhZm9ybSxcbiAgICAgICAgICB0cnVlLFxuICAgICAgICApKHRoaXMucHJvcHMuYXp1cmVBcHBQdXNoUmVjZWl2ZXJzKSxcblxuICAgICAgICBsb2dpY0FwcFJlY2VpdmVyOiBjZGt0Zi5saXN0TWFwcGVyKFxuICAgICAgICAgIG1vZGVsLm1vbml0b3JBY3Rpb25Hcm91cExvZ2ljQXBwUmVjZWl2ZXJUb1RlcnJhZm9ybSxcbiAgICAgICAgICB0cnVlLFxuICAgICAgICApKHRoaXMucHJvcHMubG9naWNBcHBSZWNlaXZlcnMpLFxuICAgICAgfSxcbiAgICApO1xuXG4gICAgLy8gVGVycmFmb3JtIE91dHB1dHNcbiAgICB0aGlzLmlkID0gYXp1cmVybU1vbml0b3JBY3Rpb25Hcm91cC5pZDtcblxuICAgIGNvbnN0IGNka3RmVGVycmFmb3JtT3V0cHV0QWN0aW9uR3JvdXBJZCA9IG5ldyBjZGt0Zi5UZXJyYWZvcm1PdXRwdXQoXG4gICAgICB0aGlzLFxuICAgICAgXCJpZFwiLFxuICAgICAge1xuICAgICAgICB2YWx1ZTogYXp1cmVybU1vbml0b3JBY3Rpb25Hcm91cC5pZCxcbiAgICAgIH0sXG4gICAgKTtcblxuICAgIC8qVGhpcyBhbGxvd3MgdGhlIFRlcnJhZm9ybSByZXNvdXJjZSBuYW1lIHRvIG1hdGNoIHRoZSBvcmlnaW5hbCBuYW1lLiBZb3UgY2FuIHJlbW92ZSB0aGUgY2FsbCBpZiB5b3UgZG9uJ3QgbmVlZCB0aGVtIHRvIG1hdGNoLiovXG4gICAgY2RrdGZUZXJyYWZvcm1PdXRwdXRBY3Rpb25Hcm91cElkLm92ZXJyaWRlTG9naWNhbElkKFwiaWRcIik7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"actiongroup.js","sourceRoot":"","sources":["../../../src/azure-actiongroup/lib/actiongroup.ts"],"names":[],"mappings":";;;AAAA,2FAAsF;AAEtF,+BAA+B;AAE/B,8CAAqD;AACrD,kCAAkC;AAElC,MAAa,WAAY,SAAQ,mBAAa;IAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA6B;QACrE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAEzC;;WAEG;QACH,MAAM,QAAQ,GAAG;YACf,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,QAAQ;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;SACvB,CAAC;QAEF,uDAAuD;QACvD,MAAM,yBAAyB,GAAG,IAAI,yCAAkB,CACtD,IAAI,EACJ,aAAa,EACb;YACE,GAAG,QAAQ;YACX,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,IAAI;YAC3C,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,eAAe,EAAE,KAAK,CAAC,UAAU,CAC/B,KAAK,CAAC,4CAA4C,EAClD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC;YAE9B,aAAa,EAAE,KAAK,CAAC,UAAU,CAC7B,KAAK,CAAC,0CAA0C,EAChD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;YAE5B,aAAa,EAAE,KAAK,CAAC,UAAU,CAC7B,KAAK,CAAC,0CAA0C,EAChD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;YAE5B,WAAW,EAAE,KAAK,CAAC,UAAU,CAC3B,KAAK,CAAC,wCAAwC,EAC9C,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YAE1B,eAAe,EAAE,KAAK,CAAC,UAAU,CAC/B,KAAK,CAAC,4CAA4C,EAClD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC;YAE9B,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAChC,KAAK,CAAC,6CAA6C,EACnD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAE/B,oBAAoB,EAAE,KAAK,CAAC,UAAU,CACpC,KAAK,CAAC,iDAAiD,EACvD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC;YAEnC,gBAAgB,EAAE,KAAK,CAAC,UAAU,CAChC,KAAK,CAAC,6CAA6C,EACnD,IAAI,CACL,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC;SAChC,CACF,CAAC;QAEF,oBAAoB;QACpB,IAAI,CAAC,EAAE,GAAG,yBAAyB,CAAC,EAAE,CAAC;QAEvC,MAAM,iCAAiC,GAAG,IAAI,KAAK,CAAC,eAAe,CACjE,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,yBAAyB,CAAC,EAAE;SACpC,CACF,CAAC;QAEF,gIAAgI;QAChI,iCAAiC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC5D,CAAC;CACF;AA3HD,kCA2HC","sourcesContent":["import { MonitorActionGroup } from \"@cdktf/provider-azurerm/lib/monitor-action-group\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AzureResource } from \"../../core-azure/lib\";\nimport * as model from \"../model\";\n\nexport class ActionGroup extends AzureResource {\n  readonly props: model.ActionGroupProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  /**\n   * Manages an Azure Monitor Action Group, which is used to trigger actions or notifications based on alerts or conditions met within Azure Monitor.\n   *\n   * An Action Group in Azure Monitor defines a collection of individual actions that are triggered when the conditions of an associated alert rule are met. Actions can include sending emails, triggering Azure Functions, calling webhooks, and more. This class allows for configuring and managing these actions, making it essential for setting up comprehensive monitoring and response systems in Azure applications.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the Action Group.\n   * @param props - Configuration properties for the Action Group. These properties may include:\n   *                - `name`: The name of the Action Group.\n   *                - `resourceGroup`: The resource group under which the Action Group is created.\n   *                - `shortName`: A shorter name for the Action Group used in notifications.\n   *                - `enabled`: Specifies if the Action Group is active. Defaults to true.\n   *                - `location`: The Azure region where the Action Group is hosted. Defaults to global.\n   *                - `tags`: A dictionary of tags to apply to the Action Group for resource management.\n   *                - Receivers: Configurations for various types of notifications (e.g., email, SMS, webhook).\n   *\n   * Example usage:\n   * ```typescript\n   * const actionGroup = new ActionGroup(this, 'myActionGroup', {\n   *   name: 'criticalAlertsGroup',\n   *   resourceGroup: myResourceGroup,\n   *   shortName: 'Alerts',\n   *   location: 'East US',\n   *   emailReceivers: [{\n   *     name: 'admin',\n   *     emailAddress: 'admin@example.com'\n   *   }],\n   *   smsReceivers: [{\n   *     name: 'adminSms',\n   *     countryCode: '1',\n   *     phoneNumber: '5551234567'\n   *   }],\n   *   tags: {\n   *     environment: 'production'\n   *   }\n   * });\n   * ```\n   * This setup creates an Action Group that sends email and SMS notifications when triggered by an alert.\n   */\n  constructor(scope: Construct, id: string, props: model.ActionGroupProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    /**\n     * Define default values.\n     */\n    const defaults = {\n      enabled: props.enabled ?? true,\n      location: props.location ?? \"global\",\n      tags: props.tags ?? {},\n    };\n\n    // Create the Action Group with the provided properties\n    const azurermMonitorActionGroup = new MonitorActionGroup(\n      this,\n      \"actiongroup\",\n      {\n        ...defaults,\n        name: props.name,\n        resourceGroupName: props.resourceGroup.name,\n        shortName: props.shortName,\n        armRoleReceiver: cdktf.listMapper(\n          model.monitorActionGroupArmRoleReceiverToTerraform,\n          true,\n        )(this.props.armRoleReceivers),\n\n        emailReceiver: cdktf.listMapper(\n          model.monitorActionGroupEmailReceiverToTerraform,\n          true,\n        )(this.props.emailReceivers),\n\n        voiceReceiver: cdktf.listMapper(\n          model.monitorActionGroupVoiceReceiverToTerraform,\n          true,\n        )(this.props.voiceReceivers),\n\n        smsReceiver: cdktf.listMapper(\n          model.monitorActionGroupSmsReceiverToTerraform,\n          true,\n        )(this.props.smsReceivers),\n\n        webhookReceiver: cdktf.listMapper(\n          model.monitorActionGroupWebhookReceiverToTerraform,\n          true,\n        )(this.props.webhookReceivers),\n\n        eventHubReceiver: cdktf.listMapper(\n          model.monitorActionGroupEventHubReceiverToTerraform,\n          true,\n        )(this.props.eventHubReceivers),\n\n        azureAppPushReceiver: cdktf.listMapper(\n          model.monitorActionGroupAzureAppPushReceiverToTerraform,\n          true,\n        )(this.props.azureAppPushReceivers),\n\n        logicAppReceiver: cdktf.listMapper(\n          model.monitorActionGroupLogicAppReceiverToTerraform,\n          true,\n        )(this.props.logicAppReceivers),\n      },\n    );\n\n    // Terraform Outputs\n    this.id = azurermMonitorActionGroup.id;\n\n    const cdktfTerraformOutputActionGroupId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: azurermMonitorActionGroup.id,\n      },\n    );\n\n    /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/\n    cdktfTerraformOutputActionGroupId.overrideLogicalId(\"id\");\n  }\n}\n"]}

package/lib/azure-applicationgateway/lib/gateway.d.ts

@@ -168,5 +168,81 @@ export interface IGatewayProps {
 export declare class Gateway extends AzureResource {
     resourceGroup: ResourceGroup;
     id: string;
+    /**
+     * Constructs a new Azure Application Gateway.
+     *
+     * @param scope - The scope in which to define this construct.
+     * @param id - The ID of this construct.
+     * @param props - The properties for configuring the Azure Application Gateway. The properties include:
+     *                - `name`: Required. Unique name for the Application Gateway within Azure.
+     *                - `location`: Required. Azure Region for deployment.
+     *                - `resourceGroup`: Required. Reference to the resource group for deployment.
+     *                - `skuTier`: Required. SKU tier of the Application Gateway (e.g., Standard, WAF).
+     *                - `skuSize`: Required. Size of the SKU for the Application Gateway.
+     *                - `capacity`: Required. Capacity (instance count) of the Application Gateway.
+     *                - `backendAddressPools`: Required. Backend address pools for the Application Gateway.
+     *                - `backendHttpSettings`: Required. Backend HTTP settings for the Application Gateway.
+     *                - `httpListeners`: Required. HTTP listeners for the Application Gateway.
+     *                - `requestRoutingRules`: Required. Request routing rules for the Application Gateway.
+     *                - `publicIpAddress`: Optional. Public IP address for the frontend.
+     *                - `privateIpAddress`: Optional. Private IP address for the frontend.
+     *                - `privateIpAddressAllocation`: Optional. Allocation method for the private IP (Static, Dynamic).
+     *                - `frontendPorts`: Optional. Frontend ports for the Application Gateway.
+     *                - `subnet`: Optional. Subnet for the Application Gateway.
+     *                - `enableHttp2`: Optional. Flag to enable HTTP2.
+     *                - `fipsEnabled`: Optional. Flag to enable FIPS-compliant algorithms.
+     *                - `firewallPolicyId`: Optional. ID of the firewall policy.
+     *                - `forceFirewallPolicyAssociation`: Optional. Flag to enforce association of the firewall policy.
+     *                - `tags`: Optional. Tags for resource management.
+     *                - Additional optional properties as described in `IGatewayProps` interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new Gateway(this, 'appGateway1', {
+     *   name: 'gatewayEast',
+     *   resourceGroup: resourceGroup,
+        location: "eastus",
+        skuTier: "Standard_v2",
+        skuSize: "Standard_v2",
+        capacity: 2,
+        publicIpAddress: publicIp,
+        subnet: subnet,
+        backendAddressPools: [
+          { name: "backend-address-pool-1" },
+          {
+            name: "backend-address-pool-2",
+            ipAddresses: ["10.1.0.4", "10.1.0.5", "10.1.0.6"],
+          },
+        ],
+        httpListeners: [
+          {
+            name: "http-listener",
+            frontendPortName: "80",
+            frontendIpConfigurationName: "Public-frontend-ip-configuration",
+            protocol: "Http",
+          },
+        ],
+        backendHttpSettings: [
+          {
+            name: "backend-http-setting",
+            port: 80,
+            protocol: "Http",
+            requestTimeout: 20,
+            cookieBasedAffinity: "Disabled",
+          },
+        ],
+        requestRoutingRules: [
+          {
+            name: "request-routing-rule-1",
+            httpListenerName: "http-listener",
+            priority: 1,
+            backendAddressPoolName: "backend-address-pool-1",
+            backendHttpSettingsName: "backend-http-setting",
+            ruleType: "Basic",
+          },
+        ],
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: IGatewayProps);
 }

package/lib/azure-applicationgateway/lib/gateway.js

@@ -10,6 +10,82 @@ const vnet = require("../../azure-virtualnetwork");
 const core_azure_1 = require("../../core-azure");
 // Define the class for Azure Application Gateway
 class Gateway extends core_azure_1.AzureResource {
+    /**
+     * Constructs a new Azure Application Gateway.
+     *
+     * @param scope - The scope in which to define this construct.
+     * @param id - The ID of this construct.
+     * @param props - The properties for configuring the Azure Application Gateway. The properties include:
+     *                - `name`: Required. Unique name for the Application Gateway within Azure.
+     *                - `location`: Required. Azure Region for deployment.
+     *                - `resourceGroup`: Required. Reference to the resource group for deployment.
+     *                - `skuTier`: Required. SKU tier of the Application Gateway (e.g., Standard, WAF).
+     *                - `skuSize`: Required. Size of the SKU for the Application Gateway.
+     *                - `capacity`: Required. Capacity (instance count) of the Application Gateway.
+     *                - `backendAddressPools`: Required. Backend address pools for the Application Gateway.
+     *                - `backendHttpSettings`: Required. Backend HTTP settings for the Application Gateway.
+     *                - `httpListeners`: Required. HTTP listeners for the Application Gateway.
+     *                - `requestRoutingRules`: Required. Request routing rules for the Application Gateway.
+     *                - `publicIpAddress`: Optional. Public IP address for the frontend.
+     *                - `privateIpAddress`: Optional. Private IP address for the frontend.
+     *                - `privateIpAddressAllocation`: Optional. Allocation method for the private IP (Static, Dynamic).
+     *                - `frontendPorts`: Optional. Frontend ports for the Application Gateway.
+     *                - `subnet`: Optional. Subnet for the Application Gateway.
+     *                - `enableHttp2`: Optional. Flag to enable HTTP2.
+     *                - `fipsEnabled`: Optional. Flag to enable FIPS-compliant algorithms.
+     *                - `firewallPolicyId`: Optional. ID of the firewall policy.
+     *                - `forceFirewallPolicyAssociation`: Optional. Flag to enforce association of the firewall policy.
+     *                - `tags`: Optional. Tags for resource management.
+     *                - Additional optional properties as described in `IGatewayProps` interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new Gateway(this, 'appGateway1', {
+     *   name: 'gatewayEast',
+     *   resourceGroup: resourceGroup,
+        location: "eastus",
+        skuTier: "Standard_v2",
+        skuSize: "Standard_v2",
+        capacity: 2,
+        publicIpAddress: publicIp,
+        subnet: subnet,
+        backendAddressPools: [
+          { name: "backend-address-pool-1" },
+          {
+            name: "backend-address-pool-2",
+            ipAddresses: ["10.1.0.4", "10.1.0.5", "10.1.0.6"],
+          },
+        ],
+        httpListeners: [
+          {
+            name: "http-listener",
+            frontendPortName: "80",
+            frontendIpConfigurationName: "Public-frontend-ip-configuration",
+            protocol: "Http",
+          },
+        ],
+        backendHttpSettings: [
+          {
+            name: "backend-http-setting",
+            port: 80,
+            protocol: "Http",
+            requestTimeout: 20,
+            cookieBasedAffinity: "Disabled",
+          },
+        ],
+        requestRoutingRules: [
+          {
+            name: "request-routing-rule-1",
+            httpListenerName: "http-listener",
+            priority: 1,
+            backendAddressPoolName: "backend-address-pool-1",
+            backendHttpSettingsName: "backend-http-setting",
+            ruleType: "Basic",
+          },
+        ],
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         // Define the identity
@@ -119,5 +195,5 @@ class Gateway extends core_azure_1.AzureResource {
 }
 exports.Gateway = Gateway;
 _a = JSII_RTTI_SYMBOL_1;
-Gateway[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_applicationgateway.Gateway", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../../src/azure-applicationgateway/lib/gateway.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApplicationGateway } from \"@cdktf/provider-azurerm/lib/application-gateway\";\nimport * as azapgw from \"@cdktf/provider-azurerm/lib/application-gateway\";\nimport { KeyVault } from \"@cdktf/provider-azurerm/lib/key-vault\";\nimport { KeyVaultAccessPolicyA } from \"@cdktf/provider-azurerm/lib/key-vault-access-policy\";\nimport { PublicIp } from \"@cdktf/provider-azurerm/lib/public-ip\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Subnet } from \"@cdktf/provider-azurerm/lib/subnet\";\nimport { UserAssignedIdentity } from \"@cdktf/provider-azurerm/lib/user-assigned-identity\";\nimport { Construct } from \"constructs\";\nimport * as vnet from \"../../azure-virtualnetwork\";\nimport { AzureResource } from \"../../core-azure\";\n\n// Define the interface for Application Gateway properties\nexport interface IGatewayProps {\n  /**\n   * Optional public IP address for the frontend of the Application Gateway.\n   */\n  publicIpAddress?: PublicIp;\n\n  /**\n   * Optional private IP address for the frontend of the Application Gateway.\n   */\n  privateIpAddress?: string;\n\n  /**\n   * Allocation method for the private IP address (e.g., Static, Dynamic).\n   */\n  privateIpAddressAllocation?: string;\n\n  /**\n   * The name of the Application Gateway.\n   */\n  readonly name: string;\n\n  /**\n   * The location where the Application Gateway will be deployed (e.g., region).\n   */\n  readonly location: string;\n\n  /**\n   * The resource group under which the Application Gateway will be deployed.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The SKU tier of the Application Gateway (e.g., Standard, WAF).\n   */\n  readonly skuTier: string;\n\n  /**\n   * The size of the SKU for the Application Gateway.\n   */\n  readonly skuSize: string;\n\n  /**\n   * The capacity (instance count) of the Application Gateway.\n   */\n  readonly capacity: number;\n\n  /**\n   * The backend address pools for the Application Gateway.\n   */\n  readonly backendAddressPools: azapgw.ApplicationGatewayBackendAddressPool[];\n\n  /**\n   * The backend HTTP settings for the Application Gateway.\n   */\n  readonly backendHttpSettings: azapgw.ApplicationGatewayBackendHttpSettings[];\n\n  /**\n   * Optional frontend ports for the Application Gateway.\n   */\n  readonly frontendPorts?: azapgw.ApplicationGatewayFrontendPort[];\n\n  /**\n   * The HTTP listeners for the Application Gateway.\n   */\n  readonly httpListeners: azapgw.ApplicationGatewayHttpListener[];\n\n  /**\n   * The request routing rules for the Application Gateway.\n   */\n  readonly requestRoutingRules: azapgw.ApplicationGatewayRequestRoutingRule[];\n\n  /**\n   * Optional subnet for the Application Gateway.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * Optional tenant ID for use with Key Vault, if applicable.\n   */\n  readonly tenantId?: string;\n\n  /**\n   * Flag to enable HTTP2.\n   */\n  readonly enableHttp2?: boolean;\n\n  /**\n   * Flag to enable FIPS-compliant algorithms.\n   */\n  readonly fipsEnabled?: boolean;\n\n  /**\n   * Optional ID of the firewall policy.\n   */\n  readonly firewallPolicyId?: string;\n\n  /**\n   * Flag to enforce association of the firewall policy.\n   */\n  readonly forceFirewallPolicyAssociation?: boolean;\n\n  /**\n   * Optional tags for the Application Gateway resource.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Optional availability zones for the Application Gateway.\n   */\n  readonly zones?: string[];\n\n  /**\n   * Optional Key Vault resource for storing SSL certificates.\n   */\n  readonly keyVault?: KeyVault;\n\n  /**\n   * Optional authentication certificates for mutual authentication.\n   */\n  readonly authenticationCertificate?: azapgw.ApplicationGatewayAuthenticationCertificate[];\n\n  /**\n   * Optional autoscale configuration for dynamically adjusting the capacity of the Application Gateway.\n   */\n  readonly autoscaleConfiguration?: azapgw.ApplicationGatewayAutoscaleConfiguration;\n\n  /**\n   * Optional custom error configurations to specify custom error pages.\n   */\n  readonly customErrorConfiguration?: azapgw.ApplicationGatewayCustomErrorConfiguration[];\n\n  /**\n   * Optional identity for the Application Gateway, used for accessing other Azure resources.\n   */\n  readonly identity?: azapgw.ApplicationGatewayIdentity;\n\n  /**\n   * Optional configurations for enabling Private Link on the Application Gateway.\n   */\n  readonly privateLinkConfiguration?: azapgw.ApplicationGatewayPrivateLinkConfiguration[];\n\n  /**\n   * Optional probes for health checks of the backend HTTP settings.\n   */\n  readonly probe?: azapgw.ApplicationGatewayProbe[];\n\n  /**\n   * Optional configurations for redirect rules.\n   */\n  readonly redirectConfiguration?: azapgw.ApplicationGatewayRedirectConfiguration[];\n\n  /**\n   * Optional rewrite rule sets for modifying HTTP request and response headers and bodies.\n   */\n  readonly rewriteRuleSet?: azapgw.ApplicationGatewayRewriteRuleSet[];\n\n  /**\n   * Optional SSL certificates for enabling HTTPS on the Application Gateway.\n   */\n  readonly sslCertificate?: azapgw.ApplicationGatewaySslCertificate[];\n\n  /**\n   * Optional SSL policy configurations, defining the protocol and cipher suites used.\n   */\n  readonly sslPolicy?: azapgw.ApplicationGatewaySslPolicy;\n\n  /**\n   * Optional SSL profiles for managing SSL termination and policy settings.\n   */\n  readonly sslProfile?: azapgw.ApplicationGatewaySslProfile[];\n\n  /**\n   * Optional timeout settings for the Application Gateway resources.\n   */\n  readonly timeouts?: azapgw.ApplicationGatewayTimeouts;\n\n  /**\n   * Optional trusted client certificates for mutual authentication.\n   */\n  readonly trustedClientCertificate?: azapgw.ApplicationGatewayTrustedClientCertificate[];\n\n  /**\n   * Optional trusted root certificates for backend authentication.\n   */\n  readonly trustedRootCertificate?: azapgw.ApplicationGatewayTrustedRootCertificate[];\n\n  /**\n   * Optional URL path map for routing based on URL paths.\n   */\n  readonly urlPathMap?: azapgw.ApplicationGatewayUrlPathMap[];\n\n  /**\n   * Optional Web Application Firewall (WAF) configuration to provide enhanced security.\n   */\n  readonly wafConfiguration?: azapgw.ApplicationGatewayWafConfiguration;\n}\n\n// Define the class for Azure Application Gateway\nexport class Gateway extends AzureResource {\n  public resourceGroup: ResourceGroup;\n  public id: string;\n\n  constructor(scope: Construct, id: string, props: IGatewayProps) {\n    super(scope, id);\n\n    // Define the identity\n    let identity;\n\n    // Check if Azure Key Vault is used and no identity is provided\n    if (props.keyVault && !props.identity) {\n      // Create a managed identity and add it to identityIds\n      const managedIdentity = new UserAssignedIdentity(\n        this,\n        \"ManagedIdentity\",\n        {\n          name: `mi-${props.name}`,\n          resourceGroupName: props.resourceGroup.name,\n          location: props.location,\n        },\n      );\n\n      identity = {\n        identityIds: [managedIdentity.id],\n        type: \"UserAssigned\",\n      };\n\n      new KeyVaultAccessPolicyA(this, \"policy\", {\n        keyVaultId: props.keyVault.id,\n        tenantId: props.tenantId || \"\",\n        objectId: managedIdentity.principalId,\n        secretPermissions: [\"Get\", \"List\"],\n      });\n    }\n\n    const defaults = {\n      subnetId:\n        props.subnet?.id ||\n        new vnet.Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default.id,\n      identity: props.identity || identity,\n    };\n\n    // WAF configuration\n    let wafConfiguration = props.wafConfiguration\n      ? {\n          enabled: props.wafConfiguration.enabled,\n          firewallMode: props.wafConfiguration.firewallMode || \"Detection\",\n          ruleSetVersion: props.wafConfiguration.ruleSetVersion || \"3.0\",\n        }\n      : undefined;\n\n    // Dynamically create frontend IP configurations\n    let frontendIpConfigs = [];\n\n    // Public IP configuration\n    if (props.publicIpAddress) {\n      frontendIpConfigs.push({\n        name: \"Public-frontend-ip-configuration\",\n        publicIpAddressId: props.publicIpAddress.id,\n      });\n    }\n\n    // Private IP configuration\n    if (props.privateIpAddress || props.privateIpAddressAllocation) {\n      frontendIpConfigs.push({\n        name: \"Private-frontend-ip-configuration\",\n        subnetId: defaults.subnetId,\n        privateIpAddress: props.privateIpAddress,\n        privateIpAddressAllocation: props.privateIpAddressAllocation,\n      });\n    }\n\n    // Set default frontend ports if not provided\n    const defaultFrontendPorts = [\n      { name: \"80\", port: 80 },\n      { name: \"443\", port: 443 },\n    ];\n\n    const frontendPorts =\n      props.frontendPorts && props.frontendPorts.length > 0\n        ? props.frontendPorts\n        : defaultFrontendPorts;\n\n    // Create the Application Gateway\n    const apgw = new ApplicationGateway(this, \"ApplicationGateway\", {\n      name: props.name,\n      resourceGroupName: props.resourceGroup.name,\n      location: props.location,\n      sslCertificate: props.sslCertificate,\n      sslPolicy: props.sslPolicy,\n      sslProfile: props.sslProfile,\n      authenticationCertificate: props.authenticationCertificate,\n      autoscaleConfiguration: props.autoscaleConfiguration,\n      customErrorConfiguration: props.customErrorConfiguration,\n      redirectConfiguration: props.redirectConfiguration,\n      rewriteRuleSet: props.rewriteRuleSet,\n      privateLinkConfiguration: props.privateLinkConfiguration,\n      wafConfiguration: wafConfiguration,\n      sku: {\n        name: props.skuSize,\n        tier: props.skuTier,\n        capacity: props.capacity,\n      },\n      gatewayIpConfiguration: [\n        {\n          subnetId: defaults.subnetId,\n          name: `${props.name}-configuration`,\n        },\n      ],\n      frontendPort: frontendPorts,\n      frontendIpConfiguration: frontendIpConfigs,\n      backendAddressPool: props.backendAddressPools,\n      backendHttpSettings: props.backendHttpSettings,\n      httpListener: props.httpListeners,\n      urlPathMap: props.urlPathMap,\n      trustedRootCertificate: props.trustedRootCertificate,\n      requestRoutingRule: props.requestRoutingRules,\n      probe: props.probe,\n      identity: defaults.identity,\n      zones: props.zones,\n      tags: props.tags,\n    });\n\n    this.id = apgw.id;\n    this.resourceGroup = props.resourceGroup;\n  }\n}\n"]}
+Gateway[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_applicationgateway.Gateway", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../../src/azure-applicationgateway/lib/gateway.ts"],"names":[],"mappings":";;;;;AAAA,yFAAqF;AAGrF,iGAA4F;AAI5F,+FAA0F;AAE1F,mDAAmD;AACnD,iDAAiD;AAwMjD,iDAAiD;AACjD,MAAa,OAAQ,SAAQ,0BAAa;IAIxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IAEH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoB;QAC5D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,sBAAsB;QACtB,IAAI,QAAQ,CAAC;QAEb,+DAA+D;QAC/D,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;YACrC,sDAAsD;YACtD,MAAM,eAAe,GAAG,IAAI,6CAAoB,CAC9C,IAAI,EACJ,iBAAiB,EACjB;gBACE,IAAI,EAAE,MAAM,KAAK,CAAC,IAAI,EAAE;gBACxB,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,IAAI;gBAC3C,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CACF,CAAC;YAEF,QAAQ,GAAG;gBACT,WAAW,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC;gBACjC,IAAI,EAAE,cAAc;aACrB,CAAC;YAEF,IAAI,+CAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE;gBACxC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE;gBAC7B,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,EAAE;gBAC9B,QAAQ,EAAE,eAAe,CAAC,WAAW;gBACrC,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;aACnC,CAAC,CAAC;SACJ;QAED,MAAM,QAAQ,GAAG;YACf,QAAQ,EACN,KAAK,CAAC,MAAM,EAAE,EAAE;gBAChB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE;oBAC7B,aAAa,EAAE,KAAK,CAAC,aAAa;iBACnC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACvB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,QAAQ;SACrC,CAAC;QAEF,oBAAoB;QACpB,IAAI,gBAAgB,GAAG,KAAK,CAAC,gBAAgB;YAC3C,CAAC,CAAC;gBACE,OAAO,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO;gBACvC,YAAY,EAAE,KAAK,CAAC,gBAAgB,CAAC,YAAY,IAAI,WAAW;gBAChE,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,cAAc,IAAI,KAAK;aAC/D;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,gDAAgD;QAChD,IAAI,iBAAiB,GAAG,EAAE,CAAC;QAE3B,0BAA0B;QAC1B,IAAI,KAAK,CAAC,eAAe,EAAE;YACzB,iBAAiB,CAAC,IAAI,CAAC;gBACrB,IAAI,EAAE,kCAAkC;gBACxC,iBAAiB,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE;aAC5C,CAAC,CAAC;SACJ;QAED,2BAA2B;QAC3B,IAAI,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,0BAA0B,EAAE;YAC9D,iBAAiB,CAAC,IAAI,CAAC;gBACrB,IAAI,EAAE,mCAAmC;gBACzC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;gBACxC,0BAA0B,EAAE,KAAK,CAAC,0BAA0B;aAC7D,CAAC,CAAC;SACJ;QAED,6CAA6C;QAC7C,MAAM,oBAAoB,GAAG;YAC3B,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE;YACxB,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE;SAC3B,CAAC;QAEF,MAAM,aAAa,GACjB,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC;YACnD,CAAC,CAAC,KAAK,CAAC,aAAa;YACrB,CAAC,CAAC,oBAAoB,CAAC;QAE3B,iCAAiC;QACjC,MAAM,IAAI,GAAG,IAAI,wCAAkB,CAAC,IAAI,EAAE,oBAAoB,EAAE;YAC9D,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,IAAI;YAC3C,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;YAC1D,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;YACxD,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;YAClD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;YACxD,gBAAgB,EAAE,gBAAgB;YAClC,GAAG,EAAE;gBACH,IAAI,EAAE,KAAK,CAAC,OAAO;gBACnB,IAAI,EAAE,KAAK,CAAC,OAAO;gBACnB,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB;YACD,sBAAsB,EAAE;gBACtB;oBACE,QAAQ,EAAE,QAAQ,CAAC,QAAQ;oBAC3B,IAAI,EAAE,GAAG,KAAK,CAAC,IAAI,gBAAgB;iBACpC;aACF;YACD,YAAY,EAAE,aAAa;YAC3B,uBAAuB,EAAE,iBAAiB;YAC1C,kBAAkB,EAAE,KAAK,CAAC,mBAAmB;YAC7C,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,YAAY,EAAE,KAAK,CAAC,aAAa;YACjC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,kBAAkB,EAAE,KAAK,CAAC,mBAAmB;YAC7C,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,IAAI,EAAE,KAAK,CAAC,IAAI;SACjB,CAAC,CAAC;QAEH,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QAClB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;IAC3C,CAAC;;AA7MH,0BA8MC","sourcesContent":["import { ApplicationGateway } from \"@cdktf/provider-azurerm/lib/application-gateway\";\nimport * as azapgw from \"@cdktf/provider-azurerm/lib/application-gateway\";\nimport { KeyVault } from \"@cdktf/provider-azurerm/lib/key-vault\";\nimport { KeyVaultAccessPolicyA } from \"@cdktf/provider-azurerm/lib/key-vault-access-policy\";\nimport { PublicIp } from \"@cdktf/provider-azurerm/lib/public-ip\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Subnet } from \"@cdktf/provider-azurerm/lib/subnet\";\nimport { UserAssignedIdentity } from \"@cdktf/provider-azurerm/lib/user-assigned-identity\";\nimport { Construct } from \"constructs\";\nimport * as vnet from \"../../azure-virtualnetwork\";\nimport { AzureResource } from \"../../core-azure\";\n\n// Define the interface for Application Gateway properties\nexport interface IGatewayProps {\n  /**\n   * Optional public IP address for the frontend of the Application Gateway.\n   */\n  publicIpAddress?: PublicIp;\n\n  /**\n   * Optional private IP address for the frontend of the Application Gateway.\n   */\n  privateIpAddress?: string;\n\n  /**\n   * Allocation method for the private IP address (e.g., Static, Dynamic).\n   */\n  privateIpAddressAllocation?: string;\n\n  /**\n   * The name of the Application Gateway.\n   */\n  readonly name: string;\n\n  /**\n   * The location where the Application Gateway will be deployed (e.g., region).\n   */\n  readonly location: string;\n\n  /**\n   * The resource group under which the Application Gateway will be deployed.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The SKU tier of the Application Gateway (e.g., Standard, WAF).\n   */\n  readonly skuTier: string;\n\n  /**\n   * The size of the SKU for the Application Gateway.\n   */\n  readonly skuSize: string;\n\n  /**\n   * The capacity (instance count) of the Application Gateway.\n   */\n  readonly capacity: number;\n\n  /**\n   * The backend address pools for the Application Gateway.\n   */\n  readonly backendAddressPools: azapgw.ApplicationGatewayBackendAddressPool[];\n\n  /**\n   * The backend HTTP settings for the Application Gateway.\n   */\n  readonly backendHttpSettings: azapgw.ApplicationGatewayBackendHttpSettings[];\n\n  /**\n   * Optional frontend ports for the Application Gateway.\n   */\n  readonly frontendPorts?: azapgw.ApplicationGatewayFrontendPort[];\n\n  /**\n   * The HTTP listeners for the Application Gateway.\n   */\n  readonly httpListeners: azapgw.ApplicationGatewayHttpListener[];\n\n  /**\n   * The request routing rules for the Application Gateway.\n   */\n  readonly requestRoutingRules: azapgw.ApplicationGatewayRequestRoutingRule[];\n\n  /**\n   * Optional subnet for the Application Gateway.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * Optional tenant ID for use with Key Vault, if applicable.\n   */\n  readonly tenantId?: string;\n\n  /**\n   * Flag to enable HTTP2.\n   */\n  readonly enableHttp2?: boolean;\n\n  /**\n   * Flag to enable FIPS-compliant algorithms.\n   */\n  readonly fipsEnabled?: boolean;\n\n  /**\n   * Optional ID of the firewall policy.\n   */\n  readonly firewallPolicyId?: string;\n\n  /**\n   * Flag to enforce association of the firewall policy.\n   */\n  readonly forceFirewallPolicyAssociation?: boolean;\n\n  /**\n   * Optional tags for the Application Gateway resource.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Optional availability zones for the Application Gateway.\n   */\n  readonly zones?: string[];\n\n  /**\n   * Optional Key Vault resource for storing SSL certificates.\n   */\n  readonly keyVault?: KeyVault;\n\n  /**\n   * Optional authentication certificates for mutual authentication.\n   */\n  readonly authenticationCertificate?: azapgw.ApplicationGatewayAuthenticationCertificate[];\n\n  /**\n   * Optional autoscale configuration for dynamically adjusting the capacity of the Application Gateway.\n   */\n  readonly autoscaleConfiguration?: azapgw.ApplicationGatewayAutoscaleConfiguration;\n\n  /**\n   * Optional custom error configurations to specify custom error pages.\n   */\n  readonly customErrorConfiguration?: azapgw.ApplicationGatewayCustomErrorConfiguration[];\n\n  /**\n   * Optional identity for the Application Gateway, used for accessing other Azure resources.\n   */\n  readonly identity?: azapgw.ApplicationGatewayIdentity;\n\n  /**\n   * Optional configurations for enabling Private Link on the Application Gateway.\n   */\n  readonly privateLinkConfiguration?: azapgw.ApplicationGatewayPrivateLinkConfiguration[];\n\n  /**\n   * Optional probes for health checks of the backend HTTP settings.\n   */\n  readonly probe?: azapgw.ApplicationGatewayProbe[];\n\n  /**\n   * Optional configurations for redirect rules.\n   */\n  readonly redirectConfiguration?: azapgw.ApplicationGatewayRedirectConfiguration[];\n\n  /**\n   * Optional rewrite rule sets for modifying HTTP request and response headers and bodies.\n   */\n  readonly rewriteRuleSet?: azapgw.ApplicationGatewayRewriteRuleSet[];\n\n  /**\n   * Optional SSL certificates for enabling HTTPS on the Application Gateway.\n   */\n  readonly sslCertificate?: azapgw.ApplicationGatewaySslCertificate[];\n\n  /**\n   * Optional SSL policy configurations, defining the protocol and cipher suites used.\n   */\n  readonly sslPolicy?: azapgw.ApplicationGatewaySslPolicy;\n\n  /**\n   * Optional SSL profiles for managing SSL termination and policy settings.\n   */\n  readonly sslProfile?: azapgw.ApplicationGatewaySslProfile[];\n\n  /**\n   * Optional timeout settings for the Application Gateway resources.\n   */\n  readonly timeouts?: azapgw.ApplicationGatewayTimeouts;\n\n  /**\n   * Optional trusted client certificates for mutual authentication.\n   */\n  readonly trustedClientCertificate?: azapgw.ApplicationGatewayTrustedClientCertificate[];\n\n  /**\n   * Optional trusted root certificates for backend authentication.\n   */\n  readonly trustedRootCertificate?: azapgw.ApplicationGatewayTrustedRootCertificate[];\n\n  /**\n   * Optional URL path map for routing based on URL paths.\n   */\n  readonly urlPathMap?: azapgw.ApplicationGatewayUrlPathMap[];\n\n  /**\n   * Optional Web Application Firewall (WAF) configuration to provide enhanced security.\n   */\n  readonly wafConfiguration?: azapgw.ApplicationGatewayWafConfiguration;\n}\n\n// Define the class for Azure Application Gateway\nexport class Gateway extends AzureResource {\n  public resourceGroup: ResourceGroup;\n  public id: string;\n\n  /**\n   * Constructs a new Azure Application Gateway.\n   *\n   * @param scope - The scope in which to define this construct.\n   * @param id - The ID of this construct.\n   * @param props - The properties for configuring the Azure Application Gateway. The properties include:\n   *                - `name`: Required. Unique name for the Application Gateway within Azure.\n   *                - `location`: Required. Azure Region for deployment.\n   *                - `resourceGroup`: Required. Reference to the resource group for deployment.\n   *                - `skuTier`: Required. SKU tier of the Application Gateway (e.g., Standard, WAF).\n   *                - `skuSize`: Required. Size of the SKU for the Application Gateway.\n   *                - `capacity`: Required. Capacity (instance count) of the Application Gateway.\n   *                - `backendAddressPools`: Required. Backend address pools for the Application Gateway.\n   *                - `backendHttpSettings`: Required. Backend HTTP settings for the Application Gateway.\n   *                - `httpListeners`: Required. HTTP listeners for the Application Gateway.\n   *                - `requestRoutingRules`: Required. Request routing rules for the Application Gateway.\n   *                - `publicIpAddress`: Optional. Public IP address for the frontend.\n   *                - `privateIpAddress`: Optional. Private IP address for the frontend.\n   *                - `privateIpAddressAllocation`: Optional. Allocation method for the private IP (Static, Dynamic).\n   *                - `frontendPorts`: Optional. Frontend ports for the Application Gateway.\n   *                - `subnet`: Optional. Subnet for the Application Gateway.\n   *                - `enableHttp2`: Optional. Flag to enable HTTP2.\n   *                - `fipsEnabled`: Optional. Flag to enable FIPS-compliant algorithms.\n   *                - `firewallPolicyId`: Optional. ID of the firewall policy.\n   *                - `forceFirewallPolicyAssociation`: Optional. Flag to enforce association of the firewall policy.\n   *                - `tags`: Optional. Tags for resource management.\n   *                - Additional optional properties as described in `IGatewayProps` interface.\n   *\n   * Example usage:\n   * ```typescript\n   * new Gateway(this, 'appGateway1', {\n   *   name: 'gatewayEast',\n   *   resourceGroup: resourceGroup,\n      location: \"eastus\",\n      skuTier: \"Standard_v2\",\n      skuSize: \"Standard_v2\",\n      capacity: 2,\n      publicIpAddress: publicIp,\n      subnet: subnet,\n      backendAddressPools: [\n        { name: \"backend-address-pool-1\" },\n        {\n          name: \"backend-address-pool-2\",\n          ipAddresses: [\"10.1.0.4\", \"10.1.0.5\", \"10.1.0.6\"],\n        },\n      ],\n      httpListeners: [\n        {\n          name: \"http-listener\",\n          frontendPortName: \"80\",\n          frontendIpConfigurationName: \"Public-frontend-ip-configuration\",\n          protocol: \"Http\",\n        },\n      ],\n      backendHttpSettings: [\n        {\n          name: \"backend-http-setting\",\n          port: 80,\n          protocol: \"Http\",\n          requestTimeout: 20,\n          cookieBasedAffinity: \"Disabled\",\n        },\n      ],\n      requestRoutingRules: [\n        {\n          name: \"request-routing-rule-1\",\n          httpListenerName: \"http-listener\",\n          priority: 1,\n          backendAddressPoolName: \"backend-address-pool-1\",\n          backendHttpSettingsName: \"backend-http-setting\",\n          ruleType: \"Basic\",\n        },\n      ],\n   * });\n   * ```\n   */\n\n  constructor(scope: Construct, id: string, props: IGatewayProps) {\n    super(scope, id);\n\n    // Define the identity\n    let identity;\n\n    // Check if Azure Key Vault is used and no identity is provided\n    if (props.keyVault && !props.identity) {\n      // Create a managed identity and add it to identityIds\n      const managedIdentity = new UserAssignedIdentity(\n        this,\n        \"ManagedIdentity\",\n        {\n          name: `mi-${props.name}`,\n          resourceGroupName: props.resourceGroup.name,\n          location: props.location,\n        },\n      );\n\n      identity = {\n        identityIds: [managedIdentity.id],\n        type: \"UserAssigned\",\n      };\n\n      new KeyVaultAccessPolicyA(this, \"policy\", {\n        keyVaultId: props.keyVault.id,\n        tenantId: props.tenantId || \"\",\n        objectId: managedIdentity.principalId,\n        secretPermissions: [\"Get\", \"List\"],\n      });\n    }\n\n    const defaults = {\n      subnetId:\n        props.subnet?.id ||\n        new vnet.Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default.id,\n      identity: props.identity || identity,\n    };\n\n    // WAF configuration\n    let wafConfiguration = props.wafConfiguration\n      ? {\n          enabled: props.wafConfiguration.enabled,\n          firewallMode: props.wafConfiguration.firewallMode || \"Detection\",\n          ruleSetVersion: props.wafConfiguration.ruleSetVersion || \"3.0\",\n        }\n      : undefined;\n\n    // Dynamically create frontend IP configurations\n    let frontendIpConfigs = [];\n\n    // Public IP configuration\n    if (props.publicIpAddress) {\n      frontendIpConfigs.push({\n        name: \"Public-frontend-ip-configuration\",\n        publicIpAddressId: props.publicIpAddress.id,\n      });\n    }\n\n    // Private IP configuration\n    if (props.privateIpAddress || props.privateIpAddressAllocation) {\n      frontendIpConfigs.push({\n        name: \"Private-frontend-ip-configuration\",\n        subnetId: defaults.subnetId,\n        privateIpAddress: props.privateIpAddress,\n        privateIpAddressAllocation: props.privateIpAddressAllocation,\n      });\n    }\n\n    // Set default frontend ports if not provided\n    const defaultFrontendPorts = [\n      { name: \"80\", port: 80 },\n      { name: \"443\", port: 443 },\n    ];\n\n    const frontendPorts =\n      props.frontendPorts && props.frontendPorts.length > 0\n        ? props.frontendPorts\n        : defaultFrontendPorts;\n\n    // Create the Application Gateway\n    const apgw = new ApplicationGateway(this, \"ApplicationGateway\", {\n      name: props.name,\n      resourceGroupName: props.resourceGroup.name,\n      location: props.location,\n      sslCertificate: props.sslCertificate,\n      sslPolicy: props.sslPolicy,\n      sslProfile: props.sslProfile,\n      authenticationCertificate: props.authenticationCertificate,\n      autoscaleConfiguration: props.autoscaleConfiguration,\n      customErrorConfiguration: props.customErrorConfiguration,\n      redirectConfiguration: props.redirectConfiguration,\n      rewriteRuleSet: props.rewriteRuleSet,\n      privateLinkConfiguration: props.privateLinkConfiguration,\n      wafConfiguration: wafConfiguration,\n      sku: {\n        name: props.skuSize,\n        tier: props.skuTier,\n        capacity: props.capacity,\n      },\n      gatewayIpConfiguration: [\n        {\n          subnetId: defaults.subnetId,\n          name: `${props.name}-configuration`,\n        },\n      ],\n      frontendPort: frontendPorts,\n      frontendIpConfiguration: frontendIpConfigs,\n      backendAddressPool: props.backendAddressPools,\n      backendHttpSettings: props.backendHttpSettings,\n      httpListener: props.httpListeners,\n      urlPathMap: props.urlPathMap,\n      trustedRootCertificate: props.trustedRootCertificate,\n      requestRoutingRule: props.requestRoutingRules,\n      probe: props.probe,\n      identity: defaults.identity,\n      zones: props.zones,\n      tags: props.tags,\n    });\n\n    this.id = apgw.id;\n    this.resourceGroup = props.resourceGroup;\n  }\n}\n"]}

package/lib/azure-applicationinsights/lib/appinsights.d.ts

@@ -54,7 +54,57 @@ export declare class AppInsights extends AzureResource {
     resourceGroup: ResourceGroup;
     id: string;
     private readonly instrumentationKey;
+    /**
+     * Constructs a new Azure Application Insights resource.
+     *
+     * @param scope - The scope in which to define this construct.
+     * @param id - The ID of this construct.
+     * @param props - The properties for configuring the Azure Application Insights. The properties include:
+     *                - `name`: Required. Unique name for the Application Insights resource within Azure.
+     *                - `location`: Required. Azure Region for deployment.
+     *                - `resourceGroup`: Required. Reference to the Azure Resource Group for deployment.
+     *                - `retentionInDays`: Optional. Number of days to retain data. Default is 90 days.
+     *                - `tags`: Optional. Tags for resource management.
+     *                - `applicationType`: Required. The type of application (e.g., web, other).
+     *                - `dailyDataCapInGb`: Optional. Daily data cap in gigabytes.
+     *                - `dailyDataCapNotificationDisabled`: Optional. Flag to disable notifications when the daily data cap is reached.
+     *                - `workspaceId`: Optional. ID of the Log Analytics Workspace to associate with Application Insights. If not provided, a new workspace is created automatically.
+     *
+     * Example usage:
+     * ```typescript
+     * new AppInsights(this, 'myAppInsights', {
+     *   name: 'myAppInsightsResource',
+     *   location: 'West US',
+     *   resourceGroup: resourceGroup,
+     *   retentionInDays: 120,
+     *   tags: {
+     *     "environment": "production"
+     *   },
+     *   applicationType: 'web',
+     *   dailyDataCapInGb: 10,
+     *   dailyDataCapNotificationDisabled: true,
+     *   workspaceId: 'existing-workspace-id'
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: AppInsightsProps);
+    /**
+     * Saves the Application Insights instrumentation key to an Azure Key Vault.
+     *
+     * This method creates a new secret in the specified Azure Key Vault with the
+     * instrumentation key of the Application Insights resource. This enables secure storage
+     * and management of the instrumentation key, facilitating secure access across various
+     * Azure services.
+     *
+     * @param keyVaultId - The unique identifier of the Azure Key Vault where the secret will be stored.
+     * @param keyVaultSecretName - The name of the secret within the Key Vault. Defaults to 'instrumentation-key'.
+     *                             This name can be used to retrieve the secret in client applications.
+     *
+     * Example usage:
+     * ```typescript
+     * appInsightsInstance.saveIKeyToKeyVault('my-key-vault-id');
+     * ```
+     */
     saveIKeyToKeyVault(keyVaultId: string, keyVaultSecretName?: string): void;
     private setupLogAnalytics;
 }