@microsoft/terraform-cdk-constructs 1.9.0 → 1.10.0

package/lib/azure-keyvault/lib/key-vault.d.ts

@@ -0,0 +1,344 @@
+/**
+ * Unified Azure Key Vault implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Key Vault
+ * (Microsoft.KeyVault/vaults) that automatically handles version management,
+ * schema validation, and property transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2023-02-01 (Active)
+ * - 2023-07-01 (Active)
+ * - 2024-11-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - Configurable SKU, tenant, RBAC and access policies
+ * - Network ACLs and public network access control
+ * - Soft-delete and purge protection support
+ */
+import * as cdktf from "cdktf";
+import { Construct } from "constructs";
+import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
+import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * SKU configuration for Key Vault
+ */
+export interface KeyVaultSku {
+    /**
+     * The SKU name (standard or premium)
+     *
+     * @default "standard"
+     */
+    readonly name: "standard" | "premium";
+    /**
+     * The SKU family. Always "A" for Key Vault.
+     *
+     * @default "A"
+     */
+    readonly family?: string;
+}
+/**
+ * Permissions configuration for an access policy
+ */
+export interface KeyVaultAccessPolicyPermissions {
+    /**
+     * Permissions for keys (e.g. "get", "list", "create", "delete")
+     */
+    readonly keys?: string[];
+    /**
+     * Permissions for secrets (e.g. "get", "list", "set", "delete")
+     */
+    readonly secrets?: string[];
+    /**
+     * Permissions for certificates (e.g. "get", "list", "create", "delete")
+     */
+    readonly certificates?: string[];
+    /**
+     * Permissions for storage (e.g. "get", "list", "set", "delete")
+     */
+    readonly storage?: string[];
+}
+/**
+ * Access policy configuration for the Key Vault
+ */
+export interface KeyVaultAccessPolicy {
+    /**
+     * The Azure Active Directory tenant ID
+     */
+    readonly tenantId: string;
+    /**
+     * The object ID of a user, service principal, or security group in AAD
+     */
+    readonly objectId: string;
+    /**
+     * The application ID of the client making the request on behalf of the user
+     */
+    readonly applicationId?: string;
+    /**
+     * The permissions granted to the identity
+     */
+    readonly permissions: KeyVaultAccessPolicyPermissions;
+}
+/**
+ * IP rule for Key Vault network ACLs
+ */
+export interface KeyVaultIpRule {
+    /**
+     * IP address or CIDR range
+     */
+    readonly value: string;
+}
+/**
+ * Virtual network rule for Key Vault network ACLs
+ */
+export interface KeyVaultVirtualNetworkRule {
+    /**
+     * Virtual network subnet resource ID
+     */
+    readonly id: string;
+    /**
+     * Whether to ignore missing VNET service endpoint
+     */
+    readonly ignoreMissingVnetServiceEndpoint?: boolean;
+}
+/**
+ * Network ACL configuration for the Key Vault
+ */
+export interface KeyVaultNetworkAcls {
+    /**
+     * Default action when no rule matches (Allow or Deny)
+     *
+     * @default "Allow"
+     */
+    readonly defaultAction?: "Allow" | "Deny";
+    /**
+     * Tells what traffic can bypass network rules. Can be 'AzureServices' or 'None'.
+     *
+     * @default "AzureServices"
+     */
+    readonly bypass?: "AzureServices" | "None";
+    /**
+     * IP rules for the Key Vault
+     */
+    readonly ipRules?: KeyVaultIpRule[];
+    /**
+     * Virtual network subnet rules for the Key Vault
+     */
+    readonly virtualNetworkRules?: KeyVaultVirtualNetworkRule[];
+}
+/**
+ * Properties for the unified Azure Key Vault
+ *
+ * Extends AzapiResourceProps with Key Vault specific properties.
+ */
+export interface KeyVaultProps extends AzapiResourceProps {
+    /**
+     * Resource group ID where the Key Vault will be created
+     */
+    readonly resourceGroupId?: string;
+    /**
+     * The SKU (pricing tier) for the Key Vault
+     *
+     * @default { name: "standard", family: "A" }
+     */
+    readonly sku?: KeyVaultSku;
+    /**
+     * The Azure Active Directory tenant ID that should be used for authenticating
+     * requests to the Key Vault. If not provided, the current tenant ID from the
+     * AZAPI client configuration is used.
+     */
+    readonly tenantId?: string;
+    /**
+     * Access policies for the Key Vault.
+     *
+     * Only applicable when `enableRbacAuthorization` is false.
+     */
+    readonly accessPolicies?: KeyVaultAccessPolicy[];
+    /**
+     * Network ACL configuration for the Key Vault
+     */
+    readonly networkAcls?: KeyVaultNetworkAcls;
+    /**
+     * Whether Azure Virtual Machines are permitted to retrieve certificates
+     * stored as secrets from the Key Vault.
+     *
+     * @default false
+     */
+    readonly enabledForDeployment?: boolean;
+    /**
+     * Whether Azure Disk Encryption is permitted to retrieve secrets from the
+     * Key Vault and unwrap keys.
+     *
+     * @default false
+     */
+    readonly enabledForDiskEncryption?: boolean;
+    /**
+     * Whether Azure Resource Manager is permitted to retrieve secrets from the
+     * Key Vault.
+     *
+     * @default false
+     */
+    readonly enabledForTemplateDeployment?: boolean;
+    /**
+     * Whether Azure RBAC is used to authorize data actions instead of access
+     * policies.
+     *
+     * @default true
+     */
+    readonly enableRbacAuthorization?: boolean;
+    /**
+     * Whether soft-delete is enabled on the Key Vault.
+     *
+     * @default true
+     */
+    readonly enableSoftDelete?: boolean;
+    /**
+     * Number of days that items should be retained after soft-delete (7-90).
+     *
+     * @default 90
+     */
+    readonly softDeleteRetentionInDays?: number;
+    /**
+     * Whether purge protection is enabled. Once enabled, this property cannot
+     * be disabled.
+     */
+    readonly enablePurgeProtection?: boolean;
+    /**
+     * Whether the Key Vault accepts traffic from public networks.
+     *
+     * @default "Enabled"
+     */
+    readonly publicNetworkAccess?: "Enabled" | "Disabled";
+    /**
+     * Properties to ignore during updates
+     *
+     * @example ["tags"]
+     */
+    readonly ignoreChanges?: string[];
+}
+/**
+ * Key Vault properties for the request body
+ */
+export interface KeyVaultBodyProperties {
+    readonly tenantId: string;
+    readonly sku: KeyVaultSku;
+    readonly accessPolicies?: KeyVaultAccessPolicy[];
+    readonly networkAcls?: KeyVaultNetworkAcls;
+    readonly enabledForDeployment?: boolean;
+    readonly enabledForDiskEncryption?: boolean;
+    readonly enabledForTemplateDeployment?: boolean;
+    readonly enableRbacAuthorization?: boolean;
+    readonly enableSoftDelete?: boolean;
+    readonly softDeleteRetentionInDays?: number;
+    readonly enablePurgeProtection?: boolean;
+    readonly publicNetworkAccess?: string;
+}
+/**
+ * The resource body interface for Azure Key Vault API calls
+ */
+export interface KeyVaultBody {
+    readonly location: string;
+    readonly tags?: {
+        [key: string]: string;
+    };
+    readonly properties: KeyVaultBodyProperties;
+}
+/**
+ * Unified Azure Key Vault implementation
+ *
+ * This class provides a single, version-aware implementation that automatically
+ * handles version resolution, schema validation, and property transformation
+ * while maintaining full JSII compliance.
+ *
+ * Azure Key Vault is a cloud service for securely storing and accessing secrets,
+ * keys, and certificates with centralized management and access control.
+ *
+ * @example
+ * // Basic usage with automatic version resolution and current tenant:
+ * const keyVault = new KeyVault(this, "kv", {
+ *   name: "my-keyvault-1234",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ * });
+ *
+ * @example
+ * // Usage with explicit version pinning and configuration:
+ * const keyVault = new KeyVault(this, "kv", {
+ *   name: "my-keyvault-1234",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "premium" },
+ *   apiVersion: "2023-07-01",
+ *   enablePurgeProtection: true,
+ *   publicNetworkAccess: "Disabled",
+ *   networkAcls: {
+ *     defaultAction: "Deny",
+ *     bypass: "AzureServices",
+ *   },
+ * });
+ *
+ * @stability stable
+ */
+export declare class KeyVault extends AzapiResource {
+    /**
+     * The input properties for this Key Vault instance
+     */
+    readonly props: KeyVaultProps;
+    readonly idOutput: cdktf.TerraformOutput;
+    readonly locationOutput: cdktf.TerraformOutput;
+    readonly nameOutput: cdktf.TerraformOutput;
+    readonly tagsOutput: cdktf.TerraformOutput;
+    readonly vaultUriOutput: cdktf.TerraformOutput;
+    /**
+     * Creates a new Azure Key Vault using the AzapiResource framework
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Key Vault
+     */
+    constructor(scope: Construct, id: string, props: KeyVaultProps);
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     */
+    protected defaultVersion(): string;
+    /**
+     * Gets the Azure resource type for Key Vault
+     */
+    protected resourceType(): string;
+    /**
+     * Gets the API schema for the resolved version
+     */
+    protected apiSchema(): ApiSchema;
+    /**
+     * Indicates that location is required for Key Vaults
+     */
+    protected requiresLocation(): boolean;
+    /**
+     * Creates the resource body for the Azure API call
+     */
+    protected createResourceBody(props: any): any;
+    /**
+     * Get the data plane URI of the Key Vault
+     *
+     * Returns the deterministic Azure public cloud Key Vault URI in the form
+     * `https://{name}.vault.azure.net/`. This avoids depending on the AZAPI
+     * resource `output` attribute which is only populated for properties listed
+     * in `response_export_values`.
+     */
+    get vaultUri(): string;
+    /**
+     * Add a tag to the Key Vault
+     */
+    addTag(key: string, value: string): void;
+    /**
+     * Remove a tag from the Key Vault
+     */
+    removeTag(key: string): void;
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    private _applyIgnoreChanges;
+}

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

@@ -0,0 +1,243 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyVault = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Key Vault implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Key Vault
+ * (Microsoft.KeyVault/vaults) that automatically handles version management,
+ * schema validation, and property transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2023-02-01 (Active)
+ * - 2023-07-01 (Active)
+ * - 2024-11-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - Configurable SKU, tenant, RBAC and access policies
+ * - Network ACLs and public network access control
+ * - Soft-delete and purge protection support
+ */
+const cdktf = require("cdktf");
+const key_vault_schemas_1 = require("./key-vault-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const data_azapi_client_config_1 = require("../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config");
+/**
+ * Unified Azure Key Vault implementation
+ *
+ * This class provides a single, version-aware implementation that automatically
+ * handles version resolution, schema validation, and property transformation
+ * while maintaining full JSII compliance.
+ *
+ * Azure Key Vault is a cloud service for securely storing and accessing secrets,
+ * keys, and certificates with centralized management and access control.
+ *
+ * @example
+ * // Basic usage with automatic version resolution and current tenant:
+ * const keyVault = new KeyVault(this, "kv", {
+ *   name: "my-keyvault-1234",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ * });
+ *
+ * @example
+ * // Usage with explicit version pinning and configuration:
+ * const keyVault = new KeyVault(this, "kv", {
+ *   name: "my-keyvault-1234",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "premium" },
+ *   apiVersion: "2023-07-01",
+ *   enablePurgeProtection: true,
+ *   publicNetworkAccess: "Disabled",
+ *   networkAcls: {
+ *     defaultAction: "Deny",
+ *     bypass: "AzureServices",
+ *   },
+ * });
+ *
+ * @stability stable
+ */
+class KeyVault extends azapi_resource_1.AzapiResource {
+    /**
+     * Creates a new Azure Key Vault using the AzapiResource framework
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Key Vault
+     */
+    constructor(scope, id, props) {
+        // Validate softDeleteRetentionInDays bounds before delegating to base class
+        if (props.softDeleteRetentionInDays !== undefined) {
+            if (props.softDeleteRetentionInDays < 7 ||
+                props.softDeleteRetentionInDays > 90) {
+                throw new Error("softDeleteRetentionInDays must be between 7 and 90 days");
+            }
+        }
+        // If tenantId is not provided, fall back to the current AZAPI client tenant.
+        // The DataAzapiClientConfig data source must be created on the parent scope
+        // so it is available before super() is called.
+        const resolvedTenantId = props.tenantId ??
+            (() => {
+                const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(scope, `${id}_client_config`, {});
+                return `\${${clientConfig.fqn}.tenant_id}`;
+            })();
+        super(scope, id, { ...props, tenantId: resolvedTenantId });
+        this.props = props;
+        // Create Terraform outputs
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Key Vault",
+        });
+        this.locationOutput = new cdktf.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.location}`,
+            description: "The location of the Key Vault",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Key Vault",
+        });
+        this.tagsOutput = new cdktf.TerraformOutput(this, "tags", {
+            value: `\${${this.terraformResource.fqn}.tags}`,
+            description: "The tags assigned to the Key Vault",
+        });
+        this.vaultUriOutput = new cdktf.TerraformOutput(this, "vault_uri", {
+            value: this.vaultUri,
+            description: "The URI of the Key Vault for performing data plane operations",
+        });
+        // Override logical IDs
+        this.idOutput.overrideLogicalId("id");
+        this.locationOutput.overrideLogicalId("location");
+        this.nameOutput.overrideLogicalId("name");
+        this.tagsOutput.overrideLogicalId("tags");
+        this.vaultUriOutput.overrideLogicalId("vault_uri");
+        // Apply ignore changes if specified
+        this._applyIgnoreChanges();
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     */
+    defaultVersion() {
+        return "2024-11-01";
+    }
+    /**
+     * Gets the Azure resource type for Key Vault
+     */
+    resourceType() {
+        return key_vault_schemas_1.KEY_VAULT_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Indicates that location is required for Key Vaults
+     */
+    requiresLocation() {
+        return true;
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            tenantId: typedProps.tenantId,
+            sku: {
+                name: typedProps.sku?.name ?? "standard",
+                family: typedProps.sku?.family ?? "A",
+            },
+            enabledForDeployment: typedProps.enabledForDeployment ?? false,
+            enabledForDiskEncryption: typedProps.enabledForDiskEncryption ?? false,
+            enabledForTemplateDeployment: typedProps.enabledForTemplateDeployment ?? false,
+            enableRbacAuthorization: typedProps.enableRbacAuthorization ?? true,
+            enableSoftDelete: typedProps.enableSoftDelete ?? true,
+            softDeleteRetentionInDays: typedProps.softDeleteRetentionInDays ?? 90,
+            publicNetworkAccess: typedProps.publicNetworkAccess ?? "Enabled",
+        };
+        if (typedProps.enablePurgeProtection !== undefined) {
+            properties.enablePurgeProtection = typedProps.enablePurgeProtection;
+        }
+        // accessPolicies is only meaningful when RBAC authorization is disabled.
+        // Always include the array (Azure requires it) - default to empty.
+        properties.accessPolicies = typedProps.accessPolicies ?? [];
+        if (typedProps.networkAcls) {
+            properties.networkAcls = {
+                defaultAction: typedProps.networkAcls.defaultAction ?? "Allow",
+                bypass: typedProps.networkAcls.bypass ?? "AzureServices",
+                ipRules: typedProps.networkAcls.ipRules ?? [],
+                virtualNetworkRules: typedProps.networkAcls.virtualNetworkRules ?? [],
+            };
+        }
+        return {
+            location: this.location,
+            tags: this.allTags(),
+            properties,
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR KEY VAULT OPERATIONS
+    // =============================================================================
+    /**
+     * Get the data plane URI of the Key Vault
+     *
+     * Returns the deterministic Azure public cloud Key Vault URI in the form
+     * `https://{name}.vault.azure.net/`. This avoids depending on the AZAPI
+     * resource `output` attribute which is only populated for properties listed
+     * in `response_export_values`.
+     */
+    get vaultUri() {
+        return `https://\${${this.terraformResource.fqn}.name}.vault.azure.net/`;
+    }
+    /**
+     * Add a tag to the Key Vault
+     */
+    addTag(key, value) {
+        if (!this.props.tags) {
+            this.props.tags = {};
+        }
+        this.props.tags[key] = value;
+    }
+    /**
+     * Remove a tag from the Key Vault
+     */
+    removeTag(key) {
+        if (this.props.tags && this.props.tags[key]) {
+            delete this.props.tags[key];
+        }
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    _applyIgnoreChanges() {
+        if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {
+            this.terraformResource.addOverride("lifecycle", [
+                {
+                    ignore_changes: this.props.ignoreChanges,
+                },
+            ]);
+        }
+    }
+}
+exports.KeyVault = KeyVault;
+_a = JSII_RTTI_SYMBOL_1;
+KeyVault[_a] = { fqn: "@microsoft/terraform-cdk-constructs.KeyVault", version: "1.10.0" };
+// Static initializer runs once when the class is first loaded
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(key_vault_schemas_1.KEY_VAULT_TYPE, key_vault_schemas_1.ALL_KEY_VAULT_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-vault.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/key-vault.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Key Vault implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Key Vault\n * (Microsoft.KeyVault/vaults) that automatically handles version management,\n * schema validation, and property transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2023-02-01 (Active)\n * - 2023-07-01 (Active)\n * - 2024-11-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full JSII compliance for multi-language support\n * - Configurable SKU, tenant, RBAC and access policies\n * - Network ACLs and public network access control\n * - Soft-delete and purge protection support\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ALL_KEY_VAULT_VERSIONS, KEY_VAULT_TYPE } from \"./key-vault-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { DataAzapiClientConfig } from \"../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * SKU configuration for Key Vault\n */\nexport interface KeyVaultSku {\n  /**\n   * The SKU name (standard or premium)\n   *\n   * @default \"standard\"\n   */\n  readonly name: \"standard\" | \"premium\";\n\n  /**\n   * The SKU family. Always \"A\" for Key Vault.\n   *\n   * @default \"A\"\n   */\n  readonly family?: string;\n}\n\n/**\n * Permissions configuration for an access policy\n */\nexport interface KeyVaultAccessPolicyPermissions {\n  /**\n   * Permissions for keys (e.g. \"get\", \"list\", \"create\", \"delete\")\n   */\n  readonly keys?: string[];\n\n  /**\n   * Permissions for secrets (e.g. \"get\", \"list\", \"set\", \"delete\")\n   */\n  readonly secrets?: string[];\n\n  /**\n   * Permissions for certificates (e.g. \"get\", \"list\", \"create\", \"delete\")\n   */\n  readonly certificates?: string[];\n\n  /**\n   * Permissions for storage (e.g. \"get\", \"list\", \"set\", \"delete\")\n   */\n  readonly storage?: string[];\n}\n\n/**\n * Access policy configuration for the Key Vault\n */\nexport interface KeyVaultAccessPolicy {\n  /**\n   * The Azure Active Directory tenant ID\n   */\n  readonly tenantId: string;\n\n  /**\n   * The object ID of a user, service principal, or security group in AAD\n   */\n  readonly objectId: string;\n\n  /**\n   * The application ID of the client making the request on behalf of the user\n   */\n  readonly applicationId?: string;\n\n  /**\n   * The permissions granted to the identity\n   */\n  readonly permissions: KeyVaultAccessPolicyPermissions;\n}\n\n/**\n * IP rule for Key Vault network ACLs\n */\nexport interface KeyVaultIpRule {\n  /**\n   * IP address or CIDR range\n   */\n  readonly value: string;\n}\n\n/**\n * Virtual network rule for Key Vault network ACLs\n */\nexport interface KeyVaultVirtualNetworkRule {\n  /**\n   * Virtual network subnet resource ID\n   */\n  readonly id: string;\n\n  /**\n   * Whether to ignore missing VNET service endpoint\n   */\n  readonly ignoreMissingVnetServiceEndpoint?: boolean;\n}\n\n/**\n * Network ACL configuration for the Key Vault\n */\nexport interface KeyVaultNetworkAcls {\n  /**\n   * Default action when no rule matches (Allow or Deny)\n   *\n   * @default \"Allow\"\n   */\n  readonly defaultAction?: \"Allow\" | \"Deny\";\n\n  /**\n   * Tells what traffic can bypass network rules. Can be 'AzureServices' or 'None'.\n   *\n   * @default \"AzureServices\"\n   */\n  readonly bypass?: \"AzureServices\" | \"None\";\n\n  /**\n   * IP rules for the Key Vault\n   */\n  readonly ipRules?: KeyVaultIpRule[];\n\n  /**\n   * Virtual network subnet rules for the Key Vault\n   */\n  readonly virtualNetworkRules?: KeyVaultVirtualNetworkRule[];\n}\n\n/**\n * Properties for the unified Azure Key Vault\n *\n * Extends AzapiResourceProps with Key Vault specific properties.\n */\nexport interface KeyVaultProps extends AzapiResourceProps {\n  /**\n   * Resource group ID where the Key Vault will be created\n   */\n  readonly resourceGroupId?: string;\n\n  /**\n   * The SKU (pricing tier) for the Key Vault\n   *\n   * @default { name: \"standard\", family: \"A\" }\n   */\n  readonly sku?: KeyVaultSku;\n\n  /**\n   * The Azure Active Directory tenant ID that should be used for authenticating\n   * requests to the Key Vault. If not provided, the current tenant ID from the\n   * AZAPI client configuration is used.\n   */\n  readonly tenantId?: string;\n\n  /**\n   * Access policies for the Key Vault.\n   *\n   * Only applicable when `enableRbacAuthorization` is false.\n   */\n  readonly accessPolicies?: KeyVaultAccessPolicy[];\n\n  /**\n   * Network ACL configuration for the Key Vault\n   */\n  readonly networkAcls?: KeyVaultNetworkAcls;\n\n  /**\n   * Whether Azure Virtual Machines are permitted to retrieve certificates\n   * stored as secrets from the Key Vault.\n   *\n   * @default false\n   */\n  readonly enabledForDeployment?: boolean;\n\n  /**\n   * Whether Azure Disk Encryption is permitted to retrieve secrets from the\n   * Key Vault and unwrap keys.\n   *\n   * @default false\n   */\n  readonly enabledForDiskEncryption?: boolean;\n\n  /**\n   * Whether Azure Resource Manager is permitted to retrieve secrets from the\n   * Key Vault.\n   *\n   * @default false\n   */\n  readonly enabledForTemplateDeployment?: boolean;\n\n  /**\n   * Whether Azure RBAC is used to authorize data actions instead of access\n   * policies.\n   *\n   * @default true\n   */\n  readonly enableRbacAuthorization?: boolean;\n\n  /**\n   * Whether soft-delete is enabled on the Key Vault.\n   *\n   * @default true\n   */\n  readonly enableSoftDelete?: boolean;\n\n  /**\n   * Number of days that items should be retained after soft-delete (7-90).\n   *\n   * @default 90\n   */\n  readonly softDeleteRetentionInDays?: number;\n\n  /**\n   * Whether purge protection is enabled. Once enabled, this property cannot\n   * be disabled.\n   */\n  readonly enablePurgeProtection?: boolean;\n\n  /**\n   * Whether the Key Vault accepts traffic from public networks.\n   *\n   * @default \"Enabled\"\n   */\n  readonly publicNetworkAccess?: \"Enabled\" | \"Disabled\";\n\n  /**\n   * Properties to ignore during updates\n   *\n   * @example [\"tags\"]\n   */\n  readonly ignoreChanges?: string[];\n}\n\n/**\n * Key Vault properties for the request body\n */\nexport interface KeyVaultBodyProperties {\n  readonly tenantId: string;\n  readonly sku: KeyVaultSku;\n  readonly accessPolicies?: KeyVaultAccessPolicy[];\n  readonly networkAcls?: KeyVaultNetworkAcls;\n  readonly enabledForDeployment?: boolean;\n  readonly enabledForDiskEncryption?: boolean;\n  readonly enabledForTemplateDeployment?: boolean;\n  readonly enableRbacAuthorization?: boolean;\n  readonly enableSoftDelete?: boolean;\n  readonly softDeleteRetentionInDays?: number;\n  readonly enablePurgeProtection?: boolean;\n  readonly publicNetworkAccess?: string;\n}\n\n/**\n * The resource body interface for Azure Key Vault API calls\n */\nexport interface KeyVaultBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly properties: KeyVaultBodyProperties;\n}\n\n/**\n * Unified Azure Key Vault implementation\n *\n * This class provides a single, version-aware implementation that automatically\n * handles version resolution, schema validation, and property transformation\n * while maintaining full JSII compliance.\n *\n * Azure Key Vault is a cloud service for securely storing and accessing secrets,\n * keys, and certificates with centralized management and access control.\n *\n * @example\n * // Basic usage with automatic version resolution and current tenant:\n * const keyVault = new KeyVault(this, \"kv\", {\n *   name: \"my-keyvault-1234\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n * });\n *\n * @example\n * // Usage with explicit version pinning and configuration:\n * const keyVault = new KeyVault(this, \"kv\", {\n *   name: \"my-keyvault-1234\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   sku: { name: \"premium\" },\n *   apiVersion: \"2023-07-01\",\n *   enablePurgeProtection: true,\n *   publicNetworkAccess: \"Disabled\",\n *   networkAcls: {\n *     defaultAction: \"Deny\",\n *     bypass: \"AzureServices\",\n *   },\n * });\n *\n * @stability stable\n */\nexport class KeyVault extends AzapiResource {\n  // Static initializer runs once when the class is first loaded\n  static {\n    AzapiResource.registerSchemas(KEY_VAULT_TYPE, ALL_KEY_VAULT_VERSIONS);\n  }\n\n  /**\n   * The input properties for this Key Vault instance\n   */\n  public readonly props: KeyVaultProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly locationOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly tagsOutput: cdktf.TerraformOutput;\n  public readonly vaultUriOutput: cdktf.TerraformOutput;\n\n  /**\n   * Creates a new Azure Key Vault using the AzapiResource framework\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Key Vault\n   */\n  constructor(scope: Construct, id: string, props: KeyVaultProps) {\n    // Validate softDeleteRetentionInDays bounds before delegating to base class\n    if (props.softDeleteRetentionInDays !== undefined) {\n      if (\n        props.softDeleteRetentionInDays < 7 ||\n        props.softDeleteRetentionInDays > 90\n      ) {\n        throw new Error(\n          \"softDeleteRetentionInDays must be between 7 and 90 days\",\n        );\n      }\n    }\n\n    // If tenantId is not provided, fall back to the current AZAPI client tenant.\n    // The DataAzapiClientConfig data source must be created on the parent scope\n    // so it is available before super() is called.\n    const resolvedTenantId =\n      props.tenantId ??\n      (() => {\n        const clientConfig = new DataAzapiClientConfig(\n          scope,\n          `${id}_client_config`,\n          {},\n        );\n        return `\\${${clientConfig.fqn}.tenant_id}`;\n      })();\n\n    super(scope, id, { ...props, tenantId: resolvedTenantId } as KeyVaultProps);\n\n    this.props = props;\n\n    // Create Terraform outputs\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Key Vault\",\n    });\n\n    this.locationOutput = new cdktf.TerraformOutput(this, \"location\", {\n      value: `\\${${this.terraformResource.fqn}.location}`,\n      description: \"The location of the Key Vault\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Key Vault\",\n    });\n\n    this.tagsOutput = new cdktf.TerraformOutput(this, \"tags\", {\n      value: `\\${${this.terraformResource.fqn}.tags}`,\n      description: \"The tags assigned to the Key Vault\",\n    });\n\n    this.vaultUriOutput = new cdktf.TerraformOutput(this, \"vault_uri\", {\n      value: this.vaultUri,\n      description:\n        \"The URI of the Key Vault for performing data plane operations\",\n    });\n\n    // Override logical IDs\n    this.idOutput.overrideLogicalId(\"id\");\n    this.locationOutput.overrideLogicalId(\"location\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.tagsOutput.overrideLogicalId(\"tags\");\n    this.vaultUriOutput.overrideLogicalId(\"vault_uri\");\n\n    // Apply ignore changes if specified\n    this._applyIgnoreChanges();\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   */\n  protected defaultVersion(): string {\n    return \"2024-11-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Key Vault\n   */\n  protected resourceType(): string {\n    return KEY_VAULT_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Indicates that location is required for Key Vaults\n   */\n  protected requiresLocation(): boolean {\n    return true;\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as KeyVaultProps;\n\n    const properties: any = {\n      tenantId: typedProps.tenantId,\n      sku: {\n        name: typedProps.sku?.name ?? \"standard\",\n        family: typedProps.sku?.family ?? \"A\",\n      },\n      enabledForDeployment: typedProps.enabledForDeployment ?? false,\n      enabledForDiskEncryption: typedProps.enabledForDiskEncryption ?? false,\n      enabledForTemplateDeployment:\n        typedProps.enabledForTemplateDeployment ?? false,\n      enableRbacAuthorization: typedProps.enableRbacAuthorization ?? true,\n      enableSoftDelete: typedProps.enableSoftDelete ?? true,\n      softDeleteRetentionInDays: typedProps.softDeleteRetentionInDays ?? 90,\n      publicNetworkAccess: typedProps.publicNetworkAccess ?? \"Enabled\",\n    };\n\n    if (typedProps.enablePurgeProtection !== undefined) {\n      properties.enablePurgeProtection = typedProps.enablePurgeProtection;\n    }\n\n    // accessPolicies is only meaningful when RBAC authorization is disabled.\n    // Always include the array (Azure requires it) - default to empty.\n    properties.accessPolicies = typedProps.accessPolicies ?? [];\n\n    if (typedProps.networkAcls) {\n      properties.networkAcls = {\n        defaultAction: typedProps.networkAcls.defaultAction ?? \"Allow\",\n        bypass: typedProps.networkAcls.bypass ?? \"AzureServices\",\n        ipRules: typedProps.networkAcls.ipRules ?? [],\n        virtualNetworkRules: typedProps.networkAcls.virtualNetworkRules ?? [],\n      };\n    }\n\n    return {\n      location: this.location,\n      tags: this.allTags(),\n      properties,\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR KEY VAULT OPERATIONS\n  // =============================================================================\n\n  /**\n   * Get the data plane URI of the Key Vault\n   *\n   * Returns the deterministic Azure public cloud Key Vault URI in the form\n   * `https://{name}.vault.azure.net/`. This avoids depending on the AZAPI\n   * resource `output` attribute which is only populated for properties listed\n   * in `response_export_values`.\n   */\n  public get vaultUri(): string {\n    return `https://\\${${this.terraformResource.fqn}.name}.vault.azure.net/`;\n  }\n\n  /**\n   * Add a tag to the Key Vault\n   */\n  public addTag(key: string, value: string): void {\n    if (!this.props.tags) {\n      (this.props as any).tags = {};\n    }\n    this.props.tags![key] = value;\n  }\n\n  /**\n   * Remove a tag from the Key Vault\n   */\n  public removeTag(key: string): void {\n    if (this.props.tags && this.props.tags[key]) {\n      delete this.props.tags[key];\n    }\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Applies ignore changes lifecycle rules if specified in props\n   */\n  private _applyIgnoreChanges(): void {\n    if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {\n      this.terraformResource.addOverride(\"lifecycle\", [\n        {\n          ignore_changes: this.props.ignoreChanges,\n        },\n      ]);\n    }\n  }\n}\n"]}

package/lib/azure-keyvault/test/key-vault.integ.d.ts

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