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

package/lib/azure-keyvault/lib/vault.js

@@ -11,6 +11,32 @@ const policy_1 = require("./policy");
 const secret_1 = require("./secret");
 const lib_1 = require("../../core-azure/lib");
 class Vault extends lib_1.AzureResource {
+    /**
+     * Constructs a new Azure Key Vault resource.
+     *
+     * This class creates and configures an Azure Key Vault, a secure store for managing secrets, keys, certificates, and other sensitive data.
+     * It supports advanced configurations such as access policies, network rules, and data retention policies.
+     *
+     * @param scope - The scope in which to define this construct, usually representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Key Vault.
+     * @param props - The properties for creating the Key Vault as defined in VaultProps. These include settings for location, SKU, tenant ID, etc.
+     *
+     * Example usage:
+     * ```typescript
+     * new Vault(this, 'MyKeyVault', {
+     *   name: 'mySecureVault',
+     *   location: 'East US',
+     *   resourceGroup: myResourceGroup,
+     *   sku: 'premium',
+     *   tenantId: 'my-tenant-id',
+     *   softDeleteRetentionDays: 90,
+     *   purgeProtection: true,
+     *   tags: {
+     *     project: 'My Application'
+     *   }
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         this.accessPolicies = [];
@@ -45,7 +71,11 @@ class Vault extends lib_1.AzureResource {
         /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/
         cdktfTerraformOutputKeyVaultname.overrideLogicalId("key_vault_name");
     }
-    // Access Policy Methods
+    /**
+     * Grants read-only access to secrets stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to secrets.
+     */
     grantSecretReaderAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
@@ -56,6 +86,11 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_secret_reader_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants administrative access to secrets stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to secrets.
+     */
     grantSecretAdminAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
@@ -74,6 +109,11 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_secret_admin_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants administrative access to certificates stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to certificates.
+     */
     grantCertAdminAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
@@ -92,6 +132,11 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_cert_admin_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants read-only access to certificates stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to certificates.
+     */
     grantCertReaderAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
@@ -102,6 +147,11 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_cert_reader_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants administrative access to keys stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to keys.
+     */
     grantKeyAdminAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
@@ -120,16 +170,27 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_key_admin_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants read-only access to keys stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to keys.
+     */
     grantKeyReaderAccess(azureAdGroupId) {
         const policyProps = {
             keyVaultId: this,
             tenantId: this.props.tenantId,
             objectId: azureAdGroupId,
-            certificatePermissions: ["Get", "List"],
+            keyPermissions: ["Get", "List"],
         };
         const policy = new policy_1.AccessPolicy(this, `kv_key_reader_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
+    /**
+     * Grants custom access based on specified options to an Azure AD group in the Key Vault.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive the custom access.
+     * @param options - Custom access options specifying various permissions for secrets, keys, certificates, and storage.
+     */
     grantCustomAccess(azureAdGroupId, options) {
         const policyProps = {
             keyVaultId: this,
@@ -140,7 +201,32 @@ class Vault extends lib_1.AzureResource {
         const policy = new policy_1.AccessPolicy(this, `kv_custom_policy_access_${azureAdGroupId}`, policyProps);
         this.accessPolicies.push(policy);
     }
-    // Create Secret Methods
+    /**
+     * Creates a new secret within the Azure Key Vault.
+     *
+     * This method facilitates the storage of sensitive information in the form of a secret within the Key Vault.
+     * Secrets are protected items such as passwords, database connection strings, or any other piece of information
+     * that needs to be securely stored and accessed. This method allows setting additional properties such as
+     * expiration date and content type for better management and compliance.
+     *
+     * @param keyVaultSecretName - The unique name for the secret within the Key Vault.
+     * @param secretValue - The sensitive information or data that needs to be securely stored as a secret.
+     * @param expirationDate - Optional. The expiration date of the secret in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the secret will no longer be valid after this date.
+     * @param contentType - Optional. A description of the type of information the secret contains (e.g., 'password', 'connectionString').
+     *                      This can be used by applications to handle the secret appropriately.
+     *
+     * Example usage:
+     * ```typescript
+     * vault.addSecret(
+     *   'myDatabasePassword',
+     *   'p@ssw0rd123!',
+     *   '2030-01-01',
+     *   'databasePassword'
+     * );
+     * ```
+     * This method does not return a value. It creates a secret within the Key Vault with the specified properties.
+     */
     addSecret(keyVaultSecretName, secretValue, expirationDate, contentType) {
         const secretProps = {
             keyVaultId: this,
@@ -152,7 +238,28 @@ class Vault extends lib_1.AzureResource {
         };
         new secret_1.Secret(this, keyVaultSecretName, secretProps);
     }
-    // Create Key Methods
+    /**
+     * Creates an RSA cryptographic key within the Azure Key Vault.
+     *
+     * This method facilitates the creation of an RSA key, which is useful for a variety of cryptographic operations such as
+     * encryption, decryption, digital signature verification, and more. The RSA key created by this method is configurable
+     * with an optional expiration date and a default key size of 2048 bits. The key operations allowed include decryption,
+     * encryption, signing, verifying signatures, and key wrapping/unwrapping.
+     *
+     * @param keyVaultKeyName - The unique name for the RSA key within the Key Vault.
+     * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the key will no longer be valid after this date.
+     * @returns A KeyVaultKey object representing the newly created RSA key within the vault.
+     *
+     * Example usage:
+     * ```typescript
+     * const rsaKey = vault.addRSAKey(
+     *   'myRSAKey',
+     *   '2030-01-01'
+     * );
+     * ```
+     * This method returns the created KeyVaultKey object, allowing further operations or references to the key.
+     */
     addRSAKey(keyVaultKeyName, expirationDate) {
         const keyProps = {
             keyVaultId: this,
@@ -166,6 +273,35 @@ class Vault extends lib_1.AzureResource {
         const key = new key_1.Key(this, keyVaultKeyName, keyProps);
         return key.vaultKey;
     }
+    /**
+     * Creates a cryptographic key within the Azure Key Vault.
+     *
+     * This method allows the creation of a cryptographic key of specified type and size within the Key Vault. The key can be
+     * configured with specific operations it can perform, such as encryption, decryption, signing, etc. An optional expiration
+     * date can also be set to control the key's lifecycle. This method is flexible, supporting various key types and sizes,
+     * making it suitable for a wide range of cryptographic needs.
+     *
+     * @param keyVaultKeyName - The unique name for the cryptographic key within the Key Vault.
+     * @param keyType - The type of cryptographic key to create (e.g., 'RSA', 'EC', 'oct-HSM').
+     * @param keySize - The size of the cryptographic key in bits (e.g., 2048, 3072, 4096 for RSA).
+     * @param keyOpts - A list of cryptographic operations that the key is allowed to perform. Possible values might include
+     *                  'encrypt', 'decrypt', 'sign', 'verify', 'wrapKey', 'unwrapKey'.
+     * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the key will no longer be valid after this date, aligning with best practices for key management.
+     * @returns A KeyVaultKey object representing the newly created cryptographic key within the vault.
+     *
+     * Example usage:
+     * ```typescript
+     * const myKey = vault.addKey(
+     *   'myKey',
+     *   'RSA',
+     *   2048,
+     *   ['encrypt', 'decrypt', 'sign', 'verify'],
+     *   '2030-12-31'
+     * );
+     * ```
+     * This method returns the created KeyVaultKey object, enabling immediate use within the application for cryptographic operations.
+     */
     addKey(keyVaultKeyName, keyType, keySize, keyOpts, expirationDate) {
         const keyProps = {
             keyVaultId: this,
@@ -179,7 +315,34 @@ class Vault extends lib_1.AzureResource {
         const key = new key_1.Key(this, keyVaultKeyName, keyProps);
         return key.vaultKey;
     }
-    // Create Certificate Methods
+    /**
+     * Creates a self-signed certificate within the Azure Key Vault.
+     *
+     * This method facilitates the creation of a self-signed certificate, which is a digital certificate that is signed by
+     * its own creator rather than a trusted authority. Self-signed certificates can be useful for testing, internal
+     * communications, or any scenario where public trust is not required. The method allows specifying subject details,
+     * DNS names for the certificate, and managing its lifecycle with action types and expiry.
+     *
+     * @param certName - The unique name for the certificate within the Key Vault.
+     * @param subject - The subject name of the certificate, typically formatted as an X.500 Distinguished Name (e.g., "CN=example.com").
+     * @param dnsNames - An array of DNS names that should be associated with this certificate. This is useful for certificates
+     *                   that need to be valid for multiple hostnames.
+     * @param actionType - Optional. Specifies the action to be performed with the certificate, such as 'create' or 'renew'.
+     * @param daysBeforeExpiry - Optional. Number of days before expiry when an action should be taken, useful for auto-renewal scenarios.
+     * @returns A KeyVaultCertificate object representing the newly created self-signed certificate.
+     *
+     * Example usage:
+     * ```typescript
+     * const myCertificate = vault.addSelfSignedCert(
+     *   'myCert',
+     *   'CN=mydomain.com',
+     *   ['mydomain.com', 'www.mydomain.com'],
+     *   'create',
+     *   30
+     * );
+     * ```
+     * This method returns the KeyVaultCertificate object, enabling it to be used immediately within the application or stored for future use.
+     */
     addSelfSignedCert(certName, subject, dnsNames, actionType, daysBeforeExpiry) {
         const keyProps = {
             keyVaultId: this,
@@ -193,6 +356,27 @@ class Vault extends lib_1.AzureResource {
         const cert = new certificate_1.SelfSignedCertificate(this, certName, keyProps);
         return cert.certificate;
     }
+    /**
+     * Adds a certificate issuer to the Azure Key Vault.
+     *
+     * This method configures a certificate issuer within the Key Vault, allowing the Key Vault to issue certificates
+     * through external providers. Configuring an issuer is essential for enabling automated certificate management
+     * processes, such as issuance and renewal, directly through the Key Vault with a specified Certificate Authority (CA).
+     *
+     * @param name - The unique name for the certificate issuer within the Key Vault.
+     * @param provider - The name of the external provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.
+     *
+     * Example usage:
+     * ```typescript
+     * vault.addCertIssuer(
+     *   'myCertIssuer',
+     *   'DigiCert'
+     * );
+     * ```
+     * This method configures a certificate issuer but does not return any value. The issuer details, including provider name
+     * and any necessary credentials (managed externally or through additional method parameters), are set up in the Key Vault
+     * for future certificate operations.
+     */
     addCertIssuer(name, provider) {
         new certificate_1.CertificateIssuer(this, name, {
             name: name,
@@ -204,5 +388,5 @@ class Vault extends lib_1.AzureResource {
 }
 exports.Vault = Vault;
 _a = JSII_RTTI_SYMBOL_1;
-Vault[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.Vault", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vault.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/vault.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  KeyVault,\n  KeyVaultNetworkAcls,\n} from \"@cdktf/provider-azurerm/lib/key-vault\";\nimport { KeyVaultCertificate } from \"@cdktf/provider-azurerm/lib/key-vault-certificate\"; // Adjust the import path based on the actual module location.\nimport { KeyVaultKey } from \"@cdktf/provider-azurerm/lib/key-vault-key\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  CertificateIssuer,\n  SelfSignedCertificate,\n  SelfSignedCertificateProps,\n} from \"./certificate\";\nimport { Key, KeyProps } from \"./key\";\nimport { AccessPolicy, AccessPolicyProps } from \"./policy\";\nimport { Secret, SecretProps } from \"./secret\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\nexport interface VaultProps {\n  /**\n   * The name of the Key Vault.\n   */\n  readonly name: string;\n  /**\n   * The Azure Region to deploy the Key Vault.\n   */\n  readonly location: string;\n  /**\n   * The name of the Azure Resource Group.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly sku?: string;\n  /**\n   * The Name of the SKU used for this Key Vault. Possible values are standard and premium.\n   */\n  readonly tenantId: string;\n  /**\n   * The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault.\n   */\n  readonly networkAcls?: KeyVaultNetworkAcls;\n  /**\n   * A map of IP network ACL rules. The key is the IP or IP range in CIDR notation.\n   * The value is a description of that IP range.\n   */\n  readonly purgeProtection?: boolean;\n  /**\n   *  Specifies whether protection against purge is enabled for this Key Vault.\n   * Setting this property to true activates protection against deletion of any active key, secret or certificate in the vault. The setting is effective only if soft delete is also enabled. The default value is false.\n   * Once activated, the property cannot be reverted to false.\n   */\n  readonly softDeleteRetentionDays?: number;\n  /**\n   * The number of days that items should be retained for once soft-deleted.\n   */\n}\n\n/**\n * Options for granting custom access permissions in Azure Key Vault.\n */\nexport interface GrantCustomAccessOptions {\n  /**\n   * Optional: A list of permissions to grant for secrets in the Key Vault.\n   * Example permissions include 'get', 'list', 'set', 'delete', etc.\n   */\n  readonly secretPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for certificates in the Key Vault.\n   * Example permissions include 'get', 'list', 'create', 'delete', etc.\n   */\n  readonly certificatePermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for keys in the Key Vault.\n   * Example permissions include 'encrypt', 'decrypt', 'wrapKey', 'unwrapKey', etc.\n   */\n  readonly keyPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for storage accounts in the Key Vault.\n   * Example permissions include 'get', 'list', 'delete', 'set', 'update', etc.\n   */\n  readonly storagePermissions?: string[];\n}\n\nexport class Vault extends AzureResource {\n  readonly props: VaultProps;\n  public keyVault: KeyVault;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  private accessPolicies: AccessPolicy[] = [];\n\n  constructor(scope: Construct, id: string, props: VaultProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Provide default values\n    const purgeProtection = props.purgeProtection ?? true;\n    const sku = props.sku ?? \"standard\";\n    const softDeleteRetentionDays = props.softDeleteRetentionDays ?? 90;\n\n    const azurermKeyVault = new KeyVault(this, \"key_vault\", {\n      name: props.name,\n      location: props.location,\n      resourceGroupName: props.resourceGroup.name,\n      tags: props.tags,\n      skuName: sku,\n      tenantId: props.tenantId,\n      networkAcls: props.networkAcls,\n      purgeProtectionEnabled: purgeProtection,\n      softDeleteRetentionDays: softDeleteRetentionDays,\n    });\n    this.id = azurermKeyVault.id;\n    this.keyVault = azurermKeyVault;\n\n    // Terraform Outputs\n    const cdktfTerraformOutputKeyVaultid = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: azurermKeyVault.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    cdktfTerraformOutputKeyVaultid.overrideLogicalId(\"id\");\n\n    const cdktfTerraformOutputKeyVaultname = new cdktf.TerraformOutput(\n      this,\n      \"key_vault_name\",\n      {\n        value: azurermKeyVault.name,\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    cdktfTerraformOutputKeyVaultname.overrideLogicalId(\"key_vault_name\");\n  }\n\n  // Access Policy Methods\n  public grantSecretReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantSecretAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantCertAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantCertReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantKeyAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      keyPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantKeyReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  public grantCustomAccess(\n    azureAdGroupId: string,\n    options: GrantCustomAccessOptions,\n  ) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      ...options,\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_custom_policy_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  // Create Secret Methods\n  public addSecret(\n    keyVaultSecretName: string,\n    secretValue: string,\n    expirationDate?: string,\n    contentType?: string,\n  ) {\n    const secretProps: SecretProps = {\n      keyVaultId: this,\n      name: keyVaultSecretName,\n      value: secretValue,\n      expirationDate: expirationDate,\n      contentType: contentType,\n      accessPolicies: this.accessPolicies,\n    };\n\n    new Secret(this, keyVaultSecretName, secretProps);\n  }\n\n  // Create Key Methods\n  public addRSAKey(\n    keyVaultKeyName: string,\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: \"RSA\",\n      keySize: 2048,\n      keyOpts: [\"decrypt\", \"encrypt\", \"sign\", \"unwrapKey\", \"verify\", \"wrapKey\"],\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  public addKey(\n    keyVaultKeyName: string,\n    keyType: string,\n    keySize: number,\n    keyOpts: string[],\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: keyType,\n      keySize: keySize,\n      keyOpts: keyOpts,\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  // Create Certificate Methods\n\n  public addSelfSignedCert(\n    certName: string,\n    subject: string,\n    dnsNames: string[],\n    actionType?: string,\n    daysBeforeExpiry?: number,\n  ): KeyVaultCertificate {\n    const keyProps: SelfSignedCertificateProps = {\n      keyVaultId: this,\n      name: certName,\n      subject: subject,\n      dnsNames: dnsNames,\n      actionType: actionType,\n      daysBeforeExpiry: daysBeforeExpiry,\n      accessPolicies: this.accessPolicies,\n    };\n    const cert = new SelfSignedCertificate(this, certName, keyProps);\n    return cert.certificate;\n  }\n\n  public addCertIssuer(name: string, provider: string) {\n    new CertificateIssuer(this, name, {\n      name: name,\n      providerName: provider,\n      keyVaultId: this,\n      accessPolicies: this.accessPolicies,\n    });\n  }\n}\n"]}
+Vault[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.Vault", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vault.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/vault.ts"],"names":[],"mappings":";;;;;AAAA,qEAG+C;AAK/C,+BAA+B;AAE/B,+CAIuB;AACvB,+BAAsC;AACtC,qCAA2D;AAC3D,qCAA+C;AAC/C,8CAAqD;AA4ErD,MAAa,KAAM,SAAQ,mBAAa;IAOtC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiB;QACzD,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QA7BX,mBAAc,GAAmB,EAAE,CAAC;QA+B1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAEzC,yBAAyB;QACzB,MAAM,eAAe,GAAG,KAAK,CAAC,eAAe,IAAI,IAAI,CAAC;QACtD,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,UAAU,CAAC;QACpC,MAAM,uBAAuB,GAAG,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC;QAEpE,MAAM,eAAe,GAAG,IAAI,oBAAQ,CAAC,IAAI,EAAE,WAAW,EAAE;YACtD,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,IAAI;YAC3C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,GAAG;YACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,sBAAsB,EAAE,eAAe;YACvC,uBAAuB,EAAE,uBAAuB;SACjD,CAAC,CAAC;QACH,IAAI,CAAC,EAAE,GAAG,eAAe,CAAC,EAAE,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC;QAEhC,oBAAoB;QACpB,MAAM,8BAA8B,GAAG,IAAI,KAAK,CAAC,eAAe,CAC9D,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,eAAe,CAAC,EAAE;SAC1B,CACF,CAAC;QAEF,gIAAgI;QAChI,8BAA8B,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAEvD,MAAM,gCAAgC,GAAG,IAAI,KAAK,CAAC,eAAe,CAChE,IAAI,EACJ,gBAAgB,EAChB;YACE,KAAK,EAAE,eAAe,CAAC,IAAI;SAC5B,CACF,CAAC;QAEF,gIAAgI;QAChI,gCAAgC,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACI,uBAAuB,CAAC,cAAsB;QACnD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SACnC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,2BAA2B,cAAc,EAAE,EAC3C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,sBAAsB,CAAC,cAAsB;QAClD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,0BAA0B,cAAc,EAAE,EAC1C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,cAAsB;QAChD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,sBAAsB,EAAE;gBACtB,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,wBAAwB,cAAc,EAAE,EACxC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,qBAAqB,CAAC,cAAsB;QACjD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,sBAAsB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SACxC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,yBAAyB,cAAc,EAAE,EACzC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,mBAAmB,CAAC,cAAsB;QAC/C,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,cAAc,EAAE;gBACd,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,uBAAuB,cAAc,EAAE,EACvC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,cAAsB;QAChD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SAChC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,wBAAwB,cAAc,EAAE,EACxC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACI,iBAAiB,CACtB,cAAsB,EACtB,OAAiC;QAEjC,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,GAAG,OAAO;SACX,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,2BAA2B,cAAc,EAAE,EAC3C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,SAAS,CACd,kBAA0B,EAC1B,WAAmB,EACnB,cAAuB,EACvB,WAAoB;QAEpB,MAAM,WAAW,GAAgB;YAC/B,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,kBAAkB;YACxB,KAAK,EAAE,WAAW;YAClB,cAAc,EAAE,cAAc;YAC9B,WAAW,EAAE,WAAW;YACxB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,IAAI,eAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,SAAS,CACd,eAAuB,EACvB,cAAuB;QAEvB,MAAM,QAAQ,GAAa;YACzB,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC;YACzE,OAAO,EAAE,cAAc;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,MAAM,GAAG,GAAG,IAAI,SAAG,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC,QAAQ,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,MAAM,CACX,eAAuB,EACvB,OAAe,EACf,OAAe,EACf,OAAiB,EACjB,cAAuB;QAEvB,MAAM,QAAQ,GAAa;YACzB,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,cAAc;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,MAAM,GAAG,GAAG,IAAI,SAAG,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC,QAAQ,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,iBAAiB,CACtB,QAAgB,EAChB,OAAe,EACf,QAAkB,EAClB,UAAmB,EACnB,gBAAyB;QAEzB,MAAM,QAAQ,GAA+B;YAC3C,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,OAAO;YAChB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,UAAU;YACtB,gBAAgB,EAAE,gBAAgB;YAClC,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,mCAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,aAAa,CAAC,IAAY,EAAE,QAAgB;QACjD,IAAI,+BAAiB,CAAC,IAAI,EAAE,IAAI,EAAE;YAChC,IAAI,EAAE,IAAI;YACV,YAAY,EAAE,QAAQ;YACtB,UAAU,EAAE,IAAI;YAChB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC,CAAC;IACL,CAAC;;AAndH,sBAodC","sourcesContent":["import {\n  KeyVault,\n  KeyVaultNetworkAcls,\n} from \"@cdktf/provider-azurerm/lib/key-vault\";\nimport { KeyVaultCertificate } from \"@cdktf/provider-azurerm/lib/key-vault-certificate\"; // Adjust the import path based on the actual module location.\nimport { KeyVaultKey } from \"@cdktf/provider-azurerm/lib/key-vault-key\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  CertificateIssuer,\n  SelfSignedCertificate,\n  SelfSignedCertificateProps,\n} from \"./certificate\";\nimport { Key, KeyProps } from \"./key\";\nimport { AccessPolicy, AccessPolicyProps } from \"./policy\";\nimport { Secret, SecretProps } from \"./secret\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\nexport interface VaultProps {\n  /**\n   * The name of the Key Vault.\n   */\n  readonly name: string;\n  /**\n   * The Azure Region to deploy the Key Vault.\n   */\n  readonly location: string;\n  /**\n   * The name of the Azure Resource Group.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly sku?: string;\n  /**\n   * The Name of the SKU used for this Key Vault. Possible values are standard and premium.\n   */\n  readonly tenantId: string;\n  /**\n   * The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault.\n   */\n  readonly networkAcls?: KeyVaultNetworkAcls;\n  /**\n   * A map of IP network ACL rules. The key is the IP or IP range in CIDR notation.\n   * The value is a description of that IP range.\n   */\n  readonly purgeProtection?: boolean;\n  /**\n   *  Specifies whether protection against purge is enabled for this Key Vault.\n   * Setting this property to true activates protection against deletion of any active key, secret or certificate in the vault. The setting is effective only if soft delete is also enabled. The default value is false.\n   * Once activated, the property cannot be reverted to false.\n   */\n  readonly softDeleteRetentionDays?: number;\n  /**\n   * The number of days that items should be retained for once soft-deleted.\n   */\n}\n\n/**\n * Options for granting custom access permissions in Azure Key Vault.\n */\nexport interface GrantCustomAccessOptions {\n  /**\n   * Optional: A list of permissions to grant for secrets in the Key Vault.\n   * Example permissions include 'get', 'list', 'set', 'delete', etc.\n   */\n  readonly secretPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for certificates in the Key Vault.\n   * Example permissions include 'get', 'list', 'create', 'delete', etc.\n   */\n  readonly certificatePermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for keys in the Key Vault.\n   * Example permissions include 'encrypt', 'decrypt', 'wrapKey', 'unwrapKey', etc.\n   */\n  readonly keyPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for storage accounts in the Key Vault.\n   * Example permissions include 'get', 'list', 'delete', 'set', 'update', etc.\n   */\n  readonly storagePermissions?: string[];\n}\n\nexport class Vault extends AzureResource {\n  readonly props: VaultProps;\n  public keyVault: KeyVault;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  private accessPolicies: AccessPolicy[] = [];\n\n  /**\n   * Constructs a new Azure Key Vault resource.\n   *\n   * This class creates and configures an Azure Key Vault, a secure store for managing secrets, keys, certificates, and other sensitive data.\n   * It supports advanced configurations such as access policies, network rules, and data retention policies.\n   *\n   * @param scope - The scope in which to define this construct, usually representing the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the Key Vault.\n   * @param props - The properties for creating the Key Vault as defined in VaultProps. These include settings for location, SKU, tenant ID, etc.\n   *\n   * Example usage:\n   * ```typescript\n   * new Vault(this, 'MyKeyVault', {\n   *   name: 'mySecureVault',\n   *   location: 'East US',\n   *   resourceGroup: myResourceGroup,\n   *   sku: 'premium',\n   *   tenantId: 'my-tenant-id',\n   *   softDeleteRetentionDays: 90,\n   *   purgeProtection: true,\n   *   tags: {\n   *     project: 'My Application'\n   *   }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: VaultProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Provide default values\n    const purgeProtection = props.purgeProtection ?? true;\n    const sku = props.sku ?? \"standard\";\n    const softDeleteRetentionDays = props.softDeleteRetentionDays ?? 90;\n\n    const azurermKeyVault = new KeyVault(this, \"key_vault\", {\n      name: props.name,\n      location: props.location,\n      resourceGroupName: props.resourceGroup.name,\n      tags: props.tags,\n      skuName: sku,\n      tenantId: props.tenantId,\n      networkAcls: props.networkAcls,\n      purgeProtectionEnabled: purgeProtection,\n      softDeleteRetentionDays: softDeleteRetentionDays,\n    });\n    this.id = azurermKeyVault.id;\n    this.keyVault = azurermKeyVault;\n\n    // Terraform Outputs\n    const cdktfTerraformOutputKeyVaultid = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: azurermKeyVault.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    cdktfTerraformOutputKeyVaultid.overrideLogicalId(\"id\");\n\n    const cdktfTerraformOutputKeyVaultname = new cdktf.TerraformOutput(\n      this,\n      \"key_vault_name\",\n      {\n        value: azurermKeyVault.name,\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    cdktfTerraformOutputKeyVaultname.overrideLogicalId(\"key_vault_name\");\n  }\n\n  /**\n   * Grants read-only access to secrets stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to secrets.\n   */\n  public grantSecretReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to secrets stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to secrets.\n   */\n  public grantSecretAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to certificates stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to certificates.\n   */\n  public grantCertAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants read-only access to certificates stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to certificates.\n   */\n  public grantCertReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to keys stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to keys.\n   */\n  public grantKeyAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      keyPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants read-only access to keys stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to keys.\n   */\n  public grantKeyReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      keyPermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants custom access based on specified options to an Azure AD group in the Key Vault.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive the custom access.\n   * @param options - Custom access options specifying various permissions for secrets, keys, certificates, and storage.\n   */\n  public grantCustomAccess(\n    azureAdGroupId: string,\n    options: GrantCustomAccessOptions,\n  ) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      ...options,\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_custom_policy_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Creates a new secret within the Azure Key Vault.\n   *\n   * This method facilitates the storage of sensitive information in the form of a secret within the Key Vault.\n   * Secrets are protected items such as passwords, database connection strings, or any other piece of information\n   * that needs to be securely stored and accessed. This method allows setting additional properties such as\n   * expiration date and content type for better management and compliance.\n   *\n   * @param keyVaultSecretName - The unique name for the secret within the Key Vault.\n   * @param secretValue - The sensitive information or data that needs to be securely stored as a secret.\n   * @param expirationDate - Optional. The expiration date of the secret in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the secret will no longer be valid after this date.\n   * @param contentType - Optional. A description of the type of information the secret contains (e.g., 'password', 'connectionString').\n   *                      This can be used by applications to handle the secret appropriately.\n   *\n   * Example usage:\n   * ```typescript\n   * vault.addSecret(\n   *   'myDatabasePassword',\n   *   'p@ssw0rd123!',\n   *   '2030-01-01',\n   *   'databasePassword'\n   * );\n   * ```\n   * This method does not return a value. It creates a secret within the Key Vault with the specified properties.\n   */\n  public addSecret(\n    keyVaultSecretName: string,\n    secretValue: string,\n    expirationDate?: string,\n    contentType?: string,\n  ) {\n    const secretProps: SecretProps = {\n      keyVaultId: this,\n      name: keyVaultSecretName,\n      value: secretValue,\n      expirationDate: expirationDate,\n      contentType: contentType,\n      accessPolicies: this.accessPolicies,\n    };\n\n    new Secret(this, keyVaultSecretName, secretProps);\n  }\n\n  /**\n   * Creates an RSA cryptographic key within the Azure Key Vault.\n   *\n   * This method facilitates the creation of an RSA key, which is useful for a variety of cryptographic operations such as\n   * encryption, decryption, digital signature verification, and more. The RSA key created by this method is configurable\n   * with an optional expiration date and a default key size of 2048 bits. The key operations allowed include decryption,\n   * encryption, signing, verifying signatures, and key wrapping/unwrapping.\n   *\n   * @param keyVaultKeyName - The unique name for the RSA key within the Key Vault.\n   * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the key will no longer be valid after this date.\n   * @returns A KeyVaultKey object representing the newly created RSA key within the vault.\n   *\n   * Example usage:\n   * ```typescript\n   * const rsaKey = vault.addRSAKey(\n   *   'myRSAKey',\n   *   '2030-01-01'\n   * );\n   * ```\n   * This method returns the created KeyVaultKey object, allowing further operations or references to the key.\n   */\n  public addRSAKey(\n    keyVaultKeyName: string,\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: \"RSA\",\n      keySize: 2048,\n      keyOpts: [\"decrypt\", \"encrypt\", \"sign\", \"unwrapKey\", \"verify\", \"wrapKey\"],\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  /**\n   * Creates a cryptographic key within the Azure Key Vault.\n   *\n   * This method allows the creation of a cryptographic key of specified type and size within the Key Vault. The key can be\n   * configured with specific operations it can perform, such as encryption, decryption, signing, etc. An optional expiration\n   * date can also be set to control the key's lifecycle. This method is flexible, supporting various key types and sizes,\n   * making it suitable for a wide range of cryptographic needs.\n   *\n   * @param keyVaultKeyName - The unique name for the cryptographic key within the Key Vault.\n   * @param keyType - The type of cryptographic key to create (e.g., 'RSA', 'EC', 'oct-HSM').\n   * @param keySize - The size of the cryptographic key in bits (e.g., 2048, 3072, 4096 for RSA).\n   * @param keyOpts - A list of cryptographic operations that the key is allowed to perform. Possible values might include\n   *                  'encrypt', 'decrypt', 'sign', 'verify', 'wrapKey', 'unwrapKey'.\n   * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the key will no longer be valid after this date, aligning with best practices for key management.\n   * @returns A KeyVaultKey object representing the newly created cryptographic key within the vault.\n   *\n   * Example usage:\n   * ```typescript\n   * const myKey = vault.addKey(\n   *   'myKey',\n   *   'RSA',\n   *   2048,\n   *   ['encrypt', 'decrypt', 'sign', 'verify'],\n   *   '2030-12-31'\n   * );\n   * ```\n   * This method returns the created KeyVaultKey object, enabling immediate use within the application for cryptographic operations.\n   */\n  public addKey(\n    keyVaultKeyName: string,\n    keyType: string,\n    keySize: number,\n    keyOpts: string[],\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: keyType,\n      keySize: keySize,\n      keyOpts: keyOpts,\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  /**\n   * Creates a self-signed certificate within the Azure Key Vault.\n   *\n   * This method facilitates the creation of a self-signed certificate, which is a digital certificate that is signed by\n   * its own creator rather than a trusted authority. Self-signed certificates can be useful for testing, internal\n   * communications, or any scenario where public trust is not required. The method allows specifying subject details,\n   * DNS names for the certificate, and managing its lifecycle with action types and expiry.\n   *\n   * @param certName - The unique name for the certificate within the Key Vault.\n   * @param subject - The subject name of the certificate, typically formatted as an X.500 Distinguished Name (e.g., \"CN=example.com\").\n   * @param dnsNames - An array of DNS names that should be associated with this certificate. This is useful for certificates\n   *                   that need to be valid for multiple hostnames.\n   * @param actionType - Optional. Specifies the action to be performed with the certificate, such as 'create' or 'renew'.\n   * @param daysBeforeExpiry - Optional. Number of days before expiry when an action should be taken, useful for auto-renewal scenarios.\n   * @returns A KeyVaultCertificate object representing the newly created self-signed certificate.\n   *\n   * Example usage:\n   * ```typescript\n   * const myCertificate = vault.addSelfSignedCert(\n   *   'myCert',\n   *   'CN=mydomain.com',\n   *   ['mydomain.com', 'www.mydomain.com'],\n   *   'create',\n   *   30\n   * );\n   * ```\n   * This method returns the KeyVaultCertificate object, enabling it to be used immediately within the application or stored for future use.\n   */\n  public addSelfSignedCert(\n    certName: string,\n    subject: string,\n    dnsNames: string[],\n    actionType?: string,\n    daysBeforeExpiry?: number,\n  ): KeyVaultCertificate {\n    const keyProps: SelfSignedCertificateProps = {\n      keyVaultId: this,\n      name: certName,\n      subject: subject,\n      dnsNames: dnsNames,\n      actionType: actionType,\n      daysBeforeExpiry: daysBeforeExpiry,\n      accessPolicies: this.accessPolicies,\n    };\n    const cert = new SelfSignedCertificate(this, certName, keyProps);\n    return cert.certificate;\n  }\n\n  /**\n   * Adds a certificate issuer to the Azure Key Vault.\n   *\n   * This method configures a certificate issuer within the Key Vault, allowing the Key Vault to issue certificates\n   * through external providers. Configuring an issuer is essential for enabling automated certificate management\n   * processes, such as issuance and renewal, directly through the Key Vault with a specified Certificate Authority (CA).\n   *\n   * @param name - The unique name for the certificate issuer within the Key Vault.\n   * @param provider - The name of the external provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.\n   *\n   * Example usage:\n   * ```typescript\n   * vault.addCertIssuer(\n   *   'myCertIssuer',\n   *   'DigiCert'\n   * );\n   * ```\n   * This method configures a certificate issuer but does not return any value. The issuer details, including provider name\n   * and any necessary credentials (managed externally or through additional method parameters), are set up in the Key Vault\n   * for future certificate operations.\n   */\n  public addCertIssuer(name: string, provider: string) {\n    new CertificateIssuer(this, name, {\n      name: name,\n      providerName: provider,\n      keyVaultId: this,\n      accessPolicies: this.accessPolicies,\n    });\n  }\n}\n"]}

package/lib/azure-kubernetes/lib/cluster.d.ts

@@ -63,10 +63,31 @@ export declare class Cluster extends AzureResource {
     /** The Resource Group associated with the AKS cluster. */
     resourceGroup: ResourceGroup;
     /**
-     * Constructs a new AKS cluster.
-     * @param scope The scope in which to define this construct.
-     * @param id The unique ID or name for this construct.
-     * @param props The properties required to configure the AKS cluster.
+     * Represents an Azure Kubernetes Service (AKS) cluster resource in Azure.
+     *
+     * This class is responsible for the creation and management of an AKS cluster, allowing for the deployment and orchestration
+     * of containerized applications using Kubernetes within the Azure cloud platform.
+     *
+     * @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 AKS cluster.
+     * @param props - The properties required to configure the AKS cluster, as defined in the ClusterProps interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new Cluster(this, 'MyAKSCluster', {
+     *   name: 'example-cluster',
+     *   location: 'East US',
+     *   defaultNodePool: {
+     *     vmSize: 'Standard_D2_v3',
+     *     nodeCount: 3,
+     *     type: 'VirtualMachineScaleSets'
+     *   },
+     *   resourceGroup: existingResourceGroup,
+     *   tags: {
+     *     environment: 'production'
+     *   }
+     * });
+     * ```
      */
     constructor(scope: Construct, id: string, props: ClusterProps);
 }

package/lib/azure-kubernetes/lib/cluster.js

@@ -10,10 +10,31 @@ const lib_1 = require("../../core-azure/lib");
  */
 class Cluster extends lib_1.AzureResource {
     /**
-     * Constructs a new AKS cluster.
-     * @param scope The scope in which to define this construct.
-     * @param id The unique ID or name for this construct.
-     * @param props The properties required to configure the AKS cluster.
+     * Represents an Azure Kubernetes Service (AKS) cluster resource in Azure.
+     *
+     * This class is responsible for the creation and management of an AKS cluster, allowing for the deployment and orchestration
+     * of containerized applications using Kubernetes within the Azure cloud platform.
+     *
+     * @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 AKS cluster.
+     * @param props - The properties required to configure the AKS cluster, as defined in the ClusterProps interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new Cluster(this, 'MyAKSCluster', {
+     *   name: 'example-cluster',
+     *   location: 'East US',
+     *   defaultNodePool: {
+     *     vmSize: 'Standard_D2_v3',
+     *     nodeCount: 3,
+     *     type: 'VirtualMachineScaleSets'
+     *   },
+     *   resourceGroup: existingResourceGroup,
+     *   tags: {
+     *     environment: 'production'
+     *   }
+     * });
+     * ```
      */
     constructor(scope, id, props) {
         super(scope, id);
@@ -38,5 +59,5 @@ class Cluster extends lib_1.AzureResource {
 }
 exports.Cluster = Cluster;
 _a = JSII_RTTI_SYMBOL_1;
-Cluster[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_kubernetes.Cluster", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../../src/azure-kubernetes/lib/cluster.ts"],"names":[],"mappings":";;;;;AAAA,uFAKwD;AAGxD,8CAAqD;AA4DrD;;GAEG;AACH,MAAa,OAAQ,SAAQ,mBAAa;IAOxC;;;;;OAKG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAmB;QAC3D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,8CAA8C;QAC9C,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAEpD,uDAAuD;QACvD,MAAM,GAAG,GAAG,IAAI,sCAAiB,CAAC,IAAI,EAAE,KAAK,EAAE;YAC7C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI;YAC1C,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,2BAA2B,EAAE,KAAK,CAAC,2BAA2B;YAC9D,SAAS,EAAE,KAAK,CAAC,IAAI;YACrB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,6BAA6B,EAAE,IAAI;YACnC,0CAA0C,EACxC,KAAK,CAAC,0CAA0C;YAClD,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,CAAC,CAAC;QAEH,oDAAoD;QACpD,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,CAAC;IACnB,CAAC;;AApCH,0BA4CC","sourcesContent":["import {\n  KubernetesCluster,\n  KubernetesClusterDefaultNodePool,\n  KubernetesClusterIdentity,\n  KubernetesClusterAzureActiveDirectoryRoleBasedAccessControl,\n} from \"@cdktf/provider-azurerm/lib/kubernetes-cluster\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Construct } from \"constructs\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\n/**\n * Interface defining the properties required to create an AKS cluster.\n */\nexport interface ClusterProps {\n  /** The name of the AKS cluster. Must be unique within the Azure region. */\n  readonly name: string;\n\n  /** The Azure region where the AKS cluster will be deployed. */\n  readonly location: string;\n\n  /** Configuration for the default node pool of the AKS cluster. */\n  readonly defaultNodePool: KubernetesClusterDefaultNodePool;\n\n  /**\n   * The Azure Resource Group where the AKS cluster will be deployed.\n   * Optional. If not provided, a new resource group will be created.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * The identity used for the AKS cluster. Can be either SystemAssigned or UserAssigned.\n   * Optional.\n   */\n  readonly identity?: KubernetesClusterIdentity;\n\n  /**\n   * Configures integration of Azure Active Directory (AAD) with Kubernetes Role-Based Access Control (RBAC) for the AKS cluster. This feature enables the use of AAD to manage user and group access permissions to the Kubernetes cluster resources, leveraging AAD's robust identity and access management capabilities.\n   *\n   * Utilizing AAD with Kubernetes RBAC provides:\n   * - Enhanced security through AAD's identity protection features.\n   * - Simplified user and group management by leveraging existing AAD definitions.\n   * - Streamlined access control for Kubernetes resources, allowing for the definition of roles and role bindings based on AAD identities.\n   *\n   * This property is optional but highly recommended for clusters where security and access governance are a priority. It allows for finer-grained access control and integrates the cluster's authentication and authorization processes with corporate identity management systems.\n   *\n   * Example configuration might include specifying the AAD tenant details, enabling Azure RBAC for Kubernetes authorization, and optionally defining specific AAD groups for cluster admin roles.\n   */\n  readonly azureActiveDirectoryRoleBasedAccessControl?: KubernetesClusterAzureActiveDirectoryRoleBasedAccessControl;\n\n  /**\n   * A list of IP address ranges that are authorized to access the AKS API server. This enhances the security of your cluster by ensuring that only traffic from these IP ranges can communicate with the Kubernetes API server.\n   *\n   * Specifying this list helps to protect your cluster from unauthorized access attempts. It's a critical security measure for clusters that are exposed to the internet. If you specify an empty array, no IP addresses will be allowed to access the API server, effectively blocking all access. If this property is not defined, all IP addresses are allowed by default, which is not recommended for production environments.\n   *\n   * Example:\n   * apiServerAuthorizedIpRanges: ['203.0.113.0/24', '198.51.100.0/24']\n   *\n   * It's important to configure this property carefully, based on your organization's network policies and access requirements.\n   */\n  readonly apiServerAuthorizedIpRanges?: string[];\n\n  /**\n   * Tags to be applied to the AKS cluster resources for organizational purposes.\n   * Key-value pairs. Optional.\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Class representing the AKS cluster resource.\n */\nexport class Cluster extends AzureResource {\n  /** The unique identifier of the AKS cluster resource. */\n  public id: string;\n\n  /** The Resource Group associated with the AKS cluster. */\n  public resourceGroup: ResourceGroup;\n\n  /**\n   * Constructs a new AKS cluster.\n   * @param scope The scope in which to define this construct.\n   * @param id The unique ID or name for this construct.\n   * @param props The properties required to configure the AKS cluster.\n   */\n  constructor(scope: Construct, id: string, props: ClusterProps) {\n    super(scope, id);\n\n    // Setup or reuse the provided resource group.\n    this.resourceGroup = this.setupResourceGroup(props);\n\n    // Create the AKS Cluster with the provided properties.\n    const aks = new KubernetesCluster(this, \"AKS\", {\n      name: props.name,\n      location: props.location,\n      resourceGroupName: this.resourceGroup.name,\n      defaultNodePool: props.defaultNodePool,\n      apiServerAuthorizedIpRanges: props.apiServerAuthorizedIpRanges,\n      dnsPrefix: props.name,\n      tags: props.tags,\n      roleBasedAccessControlEnabled: true,\n      azureActiveDirectoryRoleBasedAccessControl:\n        props.azureActiveDirectoryRoleBasedAccessControl,\n      identity: props.identity,\n    });\n\n    // Assign the AKS cluster ID for external reference.\n    this.id = aks.id;\n  }\n\n  /**\n   * Sets up the Azure Resource Group for the AKS cluster.\n   * If a resource group is not provided in the properties, a new one is created.\n   * @param props The properties provided to configure the AKS cluster.\n   * @returns The Resource Group where the AKS cluster will be deployed.\n   */\n}\n"]}
+Cluster[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_kubernetes.Cluster", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../../src/azure-kubernetes/lib/cluster.ts"],"names":[],"mappings":";;;;;AAAA,uFAKwD;AAGxD,8CAAqD;AA4DrD;;GAEG;AACH,MAAa,OAAQ,SAAQ,mBAAa;IAOxC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAmB;QAC3D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,8CAA8C;QAC9C,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAEpD,uDAAuD;QACvD,MAAM,GAAG,GAAG,IAAI,sCAAiB,CAAC,IAAI,EAAE,KAAK,EAAE;YAC7C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI;YAC1C,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,2BAA2B,EAAE,KAAK,CAAC,2BAA2B;YAC9D,SAAS,EAAE,KAAK,CAAC,IAAI;YACrB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,6BAA6B,EAAE,IAAI;YACnC,0CAA0C,EACxC,KAAK,CAAC,0CAA0C;YAClD,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,CAAC,CAAC;QAEH,oDAAoD;QACpD,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,CAAC;IACnB,CAAC;;AAzDH,0BAiEC","sourcesContent":["import {\n  KubernetesCluster,\n  KubernetesClusterDefaultNodePool,\n  KubernetesClusterIdentity,\n  KubernetesClusterAzureActiveDirectoryRoleBasedAccessControl,\n} from \"@cdktf/provider-azurerm/lib/kubernetes-cluster\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Construct } from \"constructs\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\n/**\n * Interface defining the properties required to create an AKS cluster.\n */\nexport interface ClusterProps {\n  /** The name of the AKS cluster. Must be unique within the Azure region. */\n  readonly name: string;\n\n  /** The Azure region where the AKS cluster will be deployed. */\n  readonly location: string;\n\n  /** Configuration for the default node pool of the AKS cluster. */\n  readonly defaultNodePool: KubernetesClusterDefaultNodePool;\n\n  /**\n   * The Azure Resource Group where the AKS cluster will be deployed.\n   * Optional. If not provided, a new resource group will be created.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * The identity used for the AKS cluster. Can be either SystemAssigned or UserAssigned.\n   * Optional.\n   */\n  readonly identity?: KubernetesClusterIdentity;\n\n  /**\n   * Configures integration of Azure Active Directory (AAD) with Kubernetes Role-Based Access Control (RBAC) for the AKS cluster. This feature enables the use of AAD to manage user and group access permissions to the Kubernetes cluster resources, leveraging AAD's robust identity and access management capabilities.\n   *\n   * Utilizing AAD with Kubernetes RBAC provides:\n   * - Enhanced security through AAD's identity protection features.\n   * - Simplified user and group management by leveraging existing AAD definitions.\n   * - Streamlined access control for Kubernetes resources, allowing for the definition of roles and role bindings based on AAD identities.\n   *\n   * This property is optional but highly recommended for clusters where security and access governance are a priority. It allows for finer-grained access control and integrates the cluster's authentication and authorization processes with corporate identity management systems.\n   *\n   * Example configuration might include specifying the AAD tenant details, enabling Azure RBAC for Kubernetes authorization, and optionally defining specific AAD groups for cluster admin roles.\n   */\n  readonly azureActiveDirectoryRoleBasedAccessControl?: KubernetesClusterAzureActiveDirectoryRoleBasedAccessControl;\n\n  /**\n   * A list of IP address ranges that are authorized to access the AKS API server. This enhances the security of your cluster by ensuring that only traffic from these IP ranges can communicate with the Kubernetes API server.\n   *\n   * Specifying this list helps to protect your cluster from unauthorized access attempts. It's a critical security measure for clusters that are exposed to the internet. If you specify an empty array, no IP addresses will be allowed to access the API server, effectively blocking all access. If this property is not defined, all IP addresses are allowed by default, which is not recommended for production environments.\n   *\n   * Example:\n   * apiServerAuthorizedIpRanges: ['203.0.113.0/24', '198.51.100.0/24']\n   *\n   * It's important to configure this property carefully, based on your organization's network policies and access requirements.\n   */\n  readonly apiServerAuthorizedIpRanges?: string[];\n\n  /**\n   * Tags to be applied to the AKS cluster resources for organizational purposes.\n   * Key-value pairs. Optional.\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Class representing the AKS cluster resource.\n */\nexport class Cluster extends AzureResource {\n  /** The unique identifier of the AKS cluster resource. */\n  public id: string;\n\n  /** The Resource Group associated with the AKS cluster. */\n  public resourceGroup: ResourceGroup;\n\n  /**\n   * Represents an Azure Kubernetes Service (AKS) cluster resource in Azure.\n   *\n   * This class is responsible for the creation and management of an AKS cluster, allowing for the deployment and orchestration\n   * of containerized applications using Kubernetes within the Azure cloud platform.\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 AKS cluster.\n   * @param props - The properties required to configure the AKS cluster, as defined in the ClusterProps interface.\n   *\n   * Example usage:\n   * ```typescript\n   * new Cluster(this, 'MyAKSCluster', {\n   *   name: 'example-cluster',\n   *   location: 'East US',\n   *   defaultNodePool: {\n   *     vmSize: 'Standard_D2_v3',\n   *     nodeCount: 3,\n   *     type: 'VirtualMachineScaleSets'\n   *   },\n   *   resourceGroup: existingResourceGroup,\n   *   tags: {\n   *     environment: 'production'\n   *   }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: ClusterProps) {\n    super(scope, id);\n\n    // Setup or reuse the provided resource group.\n    this.resourceGroup = this.setupResourceGroup(props);\n\n    // Create the AKS Cluster with the provided properties.\n    const aks = new KubernetesCluster(this, \"AKS\", {\n      name: props.name,\n      location: props.location,\n      resourceGroupName: this.resourceGroup.name,\n      defaultNodePool: props.defaultNodePool,\n      apiServerAuthorizedIpRanges: props.apiServerAuthorizedIpRanges,\n      dnsPrefix: props.name,\n      tags: props.tags,\n      roleBasedAccessControlEnabled: true,\n      azureActiveDirectoryRoleBasedAccessControl:\n        props.azureActiveDirectoryRoleBasedAccessControl,\n      identity: props.identity,\n    });\n\n    // Assign the AKS cluster ID for external reference.\n    this.id = aks.id;\n  }\n\n  /**\n   * Sets up the Azure Resource Group for the AKS cluster.\n   * If a resource group is not provided in the properties, a new one is created.\n   * @param props The properties provided to configure the AKS cluster.\n   * @returns The Resource Group where the AKS cluster will be deployed.\n   */\n}\n"]}

package/lib/azure-kusto/lib/cluster.d.ts

@@ -78,6 +78,59 @@ export declare class Cluster extends AzureResource {
     id: string;
     resourceGroup: ResourceGroup;
     readonly uri: string;
+    /**
+     * Represents a Kusto (Azure Data Explorer) cluster in Azure.
+     *
+     * This class is responsible for the creation and management of a Kusto Cluster, which is a highly scalable and secure
+     * analytics service for ingesting, storing, and analyzing large volumes of data. The cluster supports various configurations
+     * tailored to the needs of specific data workloads and security requirements.
+     *
+     * @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 cluster.
+     * @param kustoProps - The properties required to configure the Kusto cluster, as defined in the ClusterProps interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new Cluster(this, 'MyKustoCluster', {
+     *   name: 'example-cluster',
+     *   location: 'West US',
+     *   resourceGroup: myResourceGroup,
+     *   sku: { tier: 'Standard', name: 'D13_v2', capacity: 2 },
+     *   tags: {
+     *     project: 'Data Analytics'
+     *   }
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, kustoProps: ClusterProps);
+    /**
+     * Adds a new database to the Azure Kusto Cluster.
+     *
+     * This method creates a database within the Azure Data Explorer (Kusto) cluster, defined by the properties provided.
+     * A database in Kusto serves as a logical group to manage various tables and store data. It is essential for performing
+     * data analytics and running queries. The database configuration can include settings like hot cache and soft delete periods,
+     * which optimize query performance and manage data lifecycle according to specific requirements.
+     *
+     * @param databaseProps - The properties required to create the database. These properties should include:
+     *                        - `kusto`: Reference to the Kusto cluster to which the database will be added.
+     *                        - `name`: The name of the database, which must be unique within the cluster.
+     *                        - `hotCachePeriod`: Optional. Specifies the duration that data should be kept in cache for faster query access.
+     *                        - `softDeletePeriod`: Optional. Specifies the duration that data should be retained before it stops being accessible to queries.
+     *                          Both the hot cache and soft delete periods should be specified in ISO 8601 duration format.
+     *
+     * @returns A `Database` object representing the newly created database within the Kusto cluster.
+     *
+     * Example usage:
+     * ```typescript
+     * const myDatabase = myCluster.addDatabase({
+     *   kusto: myKustoCluster,
+     *   name: 'OperationalData',
+     *   hotCachePeriod: 'P14D', // 14 days
+     *   softDeletePeriod: 'P365D' // 1 year
+     * });
+     * ```
+     * This method facilitates the efficient setup and scaling of databases within an Azure Kusto cluster, allowing
+     * for complex data analytics operations across large datasets.
+     */
     addDatabase(databaseProps: DatabaseProps): Database;
 }