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

package/lib/azure-functionapp/lib/functionapplinux.js

@@ -137,5 +137,5 @@ class FunctionAppLinux extends lib_1.AzureResource {
 }
 exports.FunctionAppLinux = FunctionAppLinux;
 _a = JSII_RTTI_SYMBOL_1;
-FunctionAppLinux[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_functionapp.FunctionAppLinux", version: "0.0.3-pre.6" };
+FunctionAppLinux[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_functionapp.FunctionAppLinux", version: "0.0.3-pre.7" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functionapplinux.js","sourceRoot":"","sources":["../../../src/azure-functionapp/lib/functionapplinux.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  LinuxFunctionApp,\n  LinuxFunctionAppSiteConfig,\n  LinuxFunctionAppSiteConfigApplicationStack,\n  LinuxFunctionAppAuthSettings,\n  LinuxFunctionAppAuthSettingsV2,\n  LinuxFunctionAppIdentity,\n  LinuxFunctionAppConnectionString,\n} from \"@cdktf/provider-azurerm/lib/linux-function-app\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { ServicePlan } from \"@cdktf/provider-azurerm/lib/service-plan\";\nimport { StorageAccount } from \"@cdktf/provider-azurerm/lib/storage-account\";\nimport { Construct } from \"constructs\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\n/**\n * Properties for the Azure Linux Function App\n */\nexport interface FunctionAppLinuxProps {\n  /**\n   * The name of the Function App. This name must be unique within Azure.\n   */\n  readonly name: string;\n\n  /**\n   * The Azure Region where the Function App will be deployed, e.g., 'East US', 'West Europe'.\n   */\n  readonly location: string;\n\n  /**\n   * An optional reference to the resource group in which to deploy the Function App.\n   * If not provided, the Function App will be deployed in the default resource group.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * An optional reference to the storage account to be used by the Function App.\n   * If not provided, a new storage account will be created.\n   */\n  readonly storageAccount?: StorageAccount;\n\n  /**\n   * Optional runtime version specification for the Function App, such as Node.js, .NET, or Java version.\n   */\n  readonly runtimeVersion?: LinuxFunctionAppSiteConfigApplicationStack;\n\n  /**\n   * Optional ID of an existing App Service Plan to host the Function App.\n   * If not provided, a new plan will be created.\n   */\n  readonly servicePlan?: ServicePlan;\n\n  /**\n   * Optional SKU for the App Service Plan, defines the pricing tier and capabilities.\n   */\n  readonly servicePlanSku?: string;\n\n  /**\n   * Optional tags for categorizing and managing the Function App resources within Azure.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Optional site configuration for additional settings like environment variables, and connection strings.\n   */\n  readonly siteConfig?: LinuxFunctionAppSiteConfig;\n\n  /**\n   * Optional ID for the App Service Environment to be used by the service plan.\n   */\n  readonly servicePlanAppServiceEnvironmentId?: string;\n\n  /**\n   * Optional maximum count of elastic workers for the App Service Plan.\n   */\n  readonly servicePlanMaximumElasticWorkerCount?: number;\n\n  /**\n   * Optional worker count for the App Service Plan.\n   */\n  readonly servicePlanWorkerCount?: number;\n\n  /**\n   * Optional flag to enable per-site scaling for the App Service Plan.\n   */\n  readonly servicePlanPerSiteScalingEnabled?: boolean;\n\n  /**\n   * Optional flag to enable zone balancing for the App Service Plan.\n   */\n  readonly servicePlanZoneBalancingEnabled?: boolean;\n\n  /**\n   * Optional authentication settings for the Function App.\n   */\n  readonly authSettings?: LinuxFunctionAppAuthSettings;\n\n  /**\n   * Optional advanced version of authentication settings for the Function App.\n   */\n  readonly authSettingsV2?: LinuxFunctionAppAuthSettingsV2;\n\n  /**\n   * Optional identity configuration for the Function App, for use in Managed Service Identity scenarios.\n   */\n  readonly identity?: LinuxFunctionAppIdentity;\n\n  /**\n   * Optional flag to enforce HTTPS only traffic.\n   */\n  readonly httpsOnly?: boolean;\n\n  /**\n   * Optional flag to enable client certificate authentication.\n   */\n  readonly clientCertificateEnabled?: boolean;\n\n  /**\n   * Optional mode for client certificate requirement (e.g., 'Required', 'Optional').\n   */\n  readonly clientCertificateMode?: string;\n\n  /**\n   * Optional paths that are excluded from client certificate authentication.\n   */\n  readonly clientCertificateExclusionPaths?: string;\n\n  /**\n   * Optional version setting for the Azure Functions runtime.\n   */\n  readonly functionsExtensionVersion?: string;\n\n  /**\n   * Optional flag to enable or disable the Function App.\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Optional flag to enable built-in logging capabilities.\n   */\n  readonly builtinLoggingEnabled?: boolean;\n\n  /**\n   * Optional connection string for external services or databases.\n   */\n  readonly connectionString?: LinuxFunctionAppConnectionString[];\n\n  /**\n   * Optional flag to enable or disable public network access to the Function App.\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n\n  /**\n   * Optional flag indicating if the storage account uses a Managed Identity.\n   */\n  readonly storageUsesManagedIdentity?: boolean;\n\n  /**\n   * Optional access key for the storage account.\n   */\n  readonly storageAccountAccessKey?: string;\n\n  /**\n   * Optional ID of a virtual network subnet for the Function App.\n   */\n  readonly virtualNetworkSubnetId?: string;\n\n  /**\n   * Optional path to a ZIP file for deployment to the Function App.\n   */\n  readonly zipDeployFile?: string;\n\n  /**\n   * Application settings for the Azure Function App.\n   *\n   * @property { [key: string]: string } appSettings - A collection of key-value pairs that contain the settings.\n   *\n   * Note on Runtime Settings:\n   * - 'node_version' in 'site_config' sets the Node.js version.\n   *   Terraform assigns this value to 'WEBSITE_NODE_DEFAULT_VERSION' in app settings.\n   * - 'functions_extension_version' sets the Azure Functions runtime version.\n   *   Terraform assigns this value to 'FUNCTIONS_EXTENSION_VERSION' in app settings.\n   *\n   * Note on Storage Settings:\n   * - Properties like 'storage_account_access_key' are used for storage configurations.\n   *   Terraform assigns these values to keys like 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING',\n   *   'AzureWebJobsStorage' in app settings.\n   *\n   * Note on Application Insights Settings:\n   * - Use 'application_insights_connection_string' and 'application_insights_key' for Application Insights configurations.\n   *   Terraform assigns these to 'APPINSIGHTS_INSTRUMENTATIONKEY' and 'APPLICATIONINSIGHTS_CONNECTION_STRING' in app settings.\n   *\n   * Note on Health Check Settings:\n   * - 'health_check_eviction_time_in_min' configures health check settings.\n   *   Terraform assigns this value to 'WEBSITE_HEALTHCHECK_MAXPINGFAILURES' in app settings.\n   *\n   * Note on Storage Account Restriction:\n   * - To restrict your storage account to a virtual network, set 'WEBSITE_CONTENTOVERVNET' to 1 in app settings.\n   *   Ensure a predefined share is created for this configuration.\n   */\n  readonly appSettings?: { [key: string]: string };\n}\n\nexport class FunctionAppLinux extends AzureResource {\n  public id: string;\n  public readonly defaultHostname: string;\n  public readonly kind: string;\n  public readonly name: string;\n  public readonly storageAccount: StorageAccount;\n  public readonly servicePlan: ServicePlan;\n  public resourceGroup: ResourceGroup;\n  /**\n   * Constructs a new FunctionAppLinux.\n   *\n   * @param scope - The scope in which to define this construct.\n   * @param id - The ID of this construct.\n   * @param props - The properties for configuring the Azure Function App on Linux. The properties include:\n   *                - `name`: Required. Unique name for the Function App within Azure.\n   *                - `location`: Required. Azure Region for deployment.\n   *                - `resourceGroup`: Optional. Reference to the resource group for deployment.\n   *                - `storageAccount`: Optional. Reference to the storage account used by the Function App.\n   *                - `runtimeVersion`: Optional. Specifies the runtime version (Node.js, .NET, Java, etc.).\n   *                - `servicePlan`: Optional. ID of an existing App Service Plan.\n   *                - `servicePlanSku`: Optional. SKU for the App Service Plan.\n   *                - `tags`: Optional. Tags for resource management.\n   *                - `siteConfig`: Optional. Additional site configuration settings.\n   *                - Additional optional properties as described in `FunctionAppLinuxProps` interface.\n   *\n   * Example usage:\n   * ```typescript\n   * new FunctionAppLinux(this, 'premiumFA', {\n   *   name: `faprem${this.name}`,\n   *   location: 'eastus',\n   *   servicePlanSku: ServicePlanSkus.PremiumEP1,\n   *   runtimeVersion: {\n   *     dotnetVersion: '5.0',\n   *   },\n   *   tags: {\n   *     \"test\": \"test\"\n   *   }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: FunctionAppLinuxProps) {\n    super(scope, id);\n\n    this.resourceGroup = this.setupResourceGroup(props);\n    this.storageAccount = this.setupStorageAccount(props);\n    this.servicePlan = this.setupServicePlan(props);\n\n    this.resourceGroup = this.resourceGroup;\n\n    // Default siteConfig settings for each hosting plan\n    let defaultSiteConfig: LinuxFunctionAppSiteConfig = {\n      use32BitWorker: false,\n      applicationStack: {\n        nodeVersion: \"14\",\n      },\n    };\n\n    // Merge user provided siteConfig with defaults\n    const siteConfig = { ...defaultSiteConfig, ...props.siteConfig };\n\n    const defaults = {\n      httpsOnly: props.httpsOnly || true,\n      clientCertificateEnabled: props.clientCertificateEnabled || false,\n      clientCertificateMode: props.clientCertificateMode || \"Required\",\n      identity: props.identity || { type: \"SystemAssigned\" },\n      clientCertificateExclusionPaths:\n        props.clientCertificateExclusionPaths || \"\",\n      functionsExtensionVersion: props.functionsExtensionVersion || \"~4\",\n      enabled: props.enabled || true,\n      builtinLoggingEnabled: props.builtinLoggingEnabled || true,\n      publicNetworkAccessEnabled: props.publicNetworkAccessEnabled || true,\n      storageUsesManagedIdentity: props.storageUsesManagedIdentity || true,\n      storageAccountAccessKey: undefined || props.storageAccountAccessKey,\n    };\n\n    // Create the Function App\n    const functionApp = new LinuxFunctionApp(this, \"FunctionApp\", {\n      ...defaults,\n      name: props.name,\n      location: props.location,\n      resourceGroupName: this.resourceGroup.name,\n      servicePlanId: this.servicePlan.id,\n      storageAccountName: this.storageAccount.name,\n      tags: props.tags,\n      siteConfig: siteConfig,\n      appSettings: props.appSettings,\n      authSettings: props.authSettings,\n      authSettingsV2: props.authSettingsV2,\n      connectionString: props.connectionString,\n      virtualNetworkSubnetId: props.virtualNetworkSubnetId,\n      zipDeployFile: props.zipDeployFile,\n    });\n\n    this.id = functionApp.id;\n    this.defaultHostname = functionApp.defaultHostname;\n    this.kind = functionApp.kind;\n    this.name = functionApp.name;\n  }\n\n  private setupStorageAccount(props: FunctionAppLinuxProps): StorageAccount {\n    // Reference or create a new storage account that will be used by the Function App to store files\n    if (!props.storageAccount) {\n      return new StorageAccount(this, \"sa\", {\n        name: `${props.name}stacc`,\n        resourceGroupName: this.resourceGroup.name,\n        location: props.location,\n        accountReplicationType: \"LRS\",\n        accountTier: \"Standard\",\n        minTlsVersion: \"TLS1_2\",\n        tags: props.tags,\n        publicNetworkAccessEnabled: false,\n        networkRules: {\n          bypass: [\"AzureServices\"],\n          defaultAction: \"Deny\",\n        },\n      });\n    } else {\n      return props.storageAccount;\n    }\n  }\n\n  private setupServicePlan(props: FunctionAppLinuxProps): ServicePlan {\n    const servicePlanSKU = props.servicePlanSku || \"Y1\";\n\n    // Use an existing App Service Plan if the ID is provided, otherwise create a new one\n    if (!props.servicePlan) {\n      return new ServicePlan(this, \"AppServicePlan\", {\n        name: `${props.name}asp`,\n        location: props.location,\n        resourceGroupName: this.resourceGroup.name,\n        skuName: servicePlanSKU,\n        osType: \"Linux\",\n        appServiceEnvironmentId: props.servicePlanAppServiceEnvironmentId,\n        maximumElasticWorkerCount: props.servicePlanMaximumElasticWorkerCount,\n        workerCount: props.servicePlanWorkerCount,\n        perSiteScalingEnabled: props.servicePlanPerSiteScalingEnabled,\n        zoneBalancingEnabled: props.servicePlanZoneBalancingEnabled,\n        tags: props.tags,\n      });\n    } else {\n      return props.servicePlan;\n    }\n  }\n}\n"]}

package/lib/azure-keyvault/lib/certificate.d.ts

@@ -2,38 +2,132 @@ import { KeyVaultCertificate } from "@cdktf/provider-azurerm/lib/key-vault-certi
 import { Construct } from "constructs";
 import { AccessPolicy } from "./policy";
 import { Vault } from "./vault";
+/**
+ * Properties required to create a self-signed certificate within Azure Key Vault.
+ */
 export interface SelfSignedCertificateProps {
     /**
-     * The name of the certificate in the Azure Key Vault.
+     * The name of the certificate to be stored in Azure Key Vault.
      */
     readonly name: string;
+    /**
+     * The subject name for the certificate, typically represented in X.509 distinguished name format.
+     */
     readonly subject: string;
+    /**
+     * Additional DNS names to be included in the certificate. Useful for creating certificates valid for multiple hostnames.
+     */
     readonly dnsNames: string[];
+    /**
+     * The ID of the Azure Key Vault where the certificate will be created and stored.
+     */
     readonly keyVaultId: Vault;
+    /**
+     * Specifies the type of action to perform with the certificate, such as 'create' or 'renew'.
+     */
     readonly actionType?: string;
+    /**
+     * Specifies the number of days before expiry when an action should be taken (e.g., renew the certificate).
+     */
     readonly daysBeforeExpiry?: number;
+    /**
+     * Access policies defining who can access this certificate within the Azure Key Vault.
+     */
     readonly accessPolicies: AccessPolicy[];
+    /**
+     * Tags to be associated with the certificate for organizational purposes.
+     */
     readonly tags?: {
         [key: string]: string;
     };
 }
+/**
+ * Properties required to configure a certificate issuer within Azure Key Vault.
+ */
 export interface CertificateIssuerProps {
     /**
-     * The name of the certificate issuer in the Azure Key Vault.
+     * The name of the certificate issuer as it will appear in Azure Key Vault.
      */
     readonly name: string;
+    /**
+     * The name of the provider that will issue the certificate, such as 'DigiCert' or 'GlobalSign'.
+     */
     readonly providerName: string;
+    /**
+     * The ID of the Azure Key Vault where the issuer will be configured.
+     */
     readonly keyVaultId: Vault;
+    /**
+     * Access policies defining who can manage this issuer and the certificates it issues within the Key Vault.
+     */
     readonly accessPolicies: AccessPolicy[];
+    /**
+     * The username required to authenticate with the certificate provider (if applicable).
+     */
     readonly username?: string;
+    /**
+     * The password required to authenticate with the certificate provider (if applicable).
+     */
     readonly password?: string;
 }
 export declare class SelfSignedCertificate extends Construct {
     certificate: KeyVaultCertificate;
     id: string;
     secretId: string;
+    /**
+     * Constructs a self-signed certificate within an Azure Key Vault.
+     *
+     * This class is responsible for the creation and management of a self-signed certificate, making it available
+     * within an Azure Key Vault. The certificate can be used for testing or internal secure communications.
+     *
+     * @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 certificate.
+     * @param props - The properties for creating the self-signed certificate as defined in SelfSignedCertificateProps.
+     *
+     * Example usage:
+     * ```typescript
+     * new SelfSignedCertificate(this, 'MySelfSignedCert', {
+     *   name: 'exampleCert',
+     *   subject: 'CN=example.com',
+     *   dnsNames: ['example.com', 'www.example.com'],
+     *   keyVaultId: myKeyVault,
+     *   accessPolicies: [{ userId: 'user123', permissions: ['all'] }],
+     *   tags: { project: 'My Project' }
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: SelfSignedCertificateProps);
 }
 export declare class CertificateIssuer extends Construct {
+    /**
+     * Constructs a new Certificate Issuer within an Azure Key Vault.
+     *
+     * This class is responsible for setting up a certificate issuer in Azure Key Vault. A certificate issuer is an entity
+     * that issues digital certificates for use in SSL/TLS and other cryptographic security contexts. By configuring an issuer,
+     * you can manage certificate lifecycle (issue, renew, revoke) through Azure Key Vault in conjunction with external certificate
+     * authorities (CAs).
+     *
+     * @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 certificate issuer.
+     * @param props - The properties for configuring the certificate issuer as defined in CertificateIssuerProps. These properties include:
+     *                - `name`: Required. The name of the issuer as it will appear in Azure Key Vault.
+     *                - `providerName`: Required. The name of the provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.
+     *                - `keyVaultId`: Required. The ID of the Azure Key Vault where the issuer will be configured.
+     *                - `accessPolicies`: Required. Access policies defining who can manage this issuer within the Key Vault.
+     *                - `username`: Optional. The username required to authenticate with the certificate provider (if applicable).
+     *                - `password`: Optional. The password required to authenticate with the certificate provider (if applicable).
+     *
+     * Example usage:
+     * ```typescript
+     * new CertificateIssuer(this, 'MyCertIssuer', {
+     *   name: 'MyIssuer',
+     *   providerName: 'DigiCert',
+     *   keyVaultId: myKeyVault,
+     *   accessPolicies: [{ userId: 'user123', permissions: ['manageIssuer'] }],
+     *   username: 'user@example.com',
+     *   password: 'securepassword'
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: CertificateIssuerProps);
 }

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

@@ -7,6 +7,28 @@ const key_vault_certificate_1 = require("@cdktf/provider-azurerm/lib/key-vault-c
 const key_vault_certificate_issuer_1 = require("@cdktf/provider-azurerm/lib/key-vault-certificate-issuer");
 const constructs_1 = require("constructs");
 class SelfSignedCertificate extends constructs_1.Construct {
+    /**
+     * Constructs a self-signed certificate within an Azure Key Vault.
+     *
+     * This class is responsible for the creation and management of a self-signed certificate, making it available
+     * within an Azure Key Vault. The certificate can be used for testing or internal secure communications.
+     *
+     * @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 certificate.
+     * @param props - The properties for creating the self-signed certificate as defined in SelfSignedCertificateProps.
+     *
+     * Example usage:
+     * ```typescript
+     * new SelfSignedCertificate(this, 'MySelfSignedCert', {
+     *   name: 'exampleCert',
+     *   subject: 'CN=example.com',
+     *   dnsNames: ['example.com', 'www.example.com'],
+     *   keyVaultId: myKeyVault,
+     *   accessPolicies: [{ userId: 'user123', permissions: ['all'] }],
+     *   tags: { project: 'My Project' }
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         // Provide default values
@@ -70,8 +92,38 @@ class SelfSignedCertificate extends constructs_1.Construct {
 }
 exports.SelfSignedCertificate = SelfSignedCertificate;
 _a = JSII_RTTI_SYMBOL_1;
-SelfSignedCertificate[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.SelfSignedCertificate", version: "0.0.3-pre.6" };
+SelfSignedCertificate[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.SelfSignedCertificate", version: "0.0.3-pre.7" };
 class CertificateIssuer extends constructs_1.Construct {
+    /**
+     * Constructs a new Certificate Issuer within an Azure Key Vault.
+     *
+     * This class is responsible for setting up a certificate issuer in Azure Key Vault. A certificate issuer is an entity
+     * that issues digital certificates for use in SSL/TLS and other cryptographic security contexts. By configuring an issuer,
+     * you can manage certificate lifecycle (issue, renew, revoke) through Azure Key Vault in conjunction with external certificate
+     * authorities (CAs).
+     *
+     * @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 certificate issuer.
+     * @param props - The properties for configuring the certificate issuer as defined in CertificateIssuerProps. These properties include:
+     *                - `name`: Required. The name of the issuer as it will appear in Azure Key Vault.
+     *                - `providerName`: Required. The name of the provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.
+     *                - `keyVaultId`: Required. The ID of the Azure Key Vault where the issuer will be configured.
+     *                - `accessPolicies`: Required. Access policies defining who can manage this issuer within the Key Vault.
+     *                - `username`: Optional. The username required to authenticate with the certificate provider (if applicable).
+     *                - `password`: Optional. The password required to authenticate with the certificate provider (if applicable).
+     *
+     * Example usage:
+     * ```typescript
+     * new CertificateIssuer(this, 'MyCertIssuer', {
+     *   name: 'MyIssuer',
+     *   providerName: 'DigiCert',
+     *   keyVaultId: myKeyVault,
+     *   accessPolicies: [{ userId: 'user123', permissions: ['manageIssuer'] }],
+     *   username: 'user@example.com',
+     *   password: 'securepassword'
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         const certificateIssuer = new key_vault_certificate_issuer_1.KeyVaultCertificateIssuer(this, "AzureKeyVaultCertificate", {
@@ -90,5 +142,5 @@ class CertificateIssuer extends constructs_1.Construct {
 }
 exports.CertificateIssuer = CertificateIssuer;
 _b = JSII_RTTI_SYMBOL_1;
-CertificateIssuer[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.CertificateIssuer", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/certificate.ts"],"names":[],"mappings":";;;;;AAAA,6FAAwF,CAAC,8DAA8D;AACvJ,2GAAqG;AACrG,2CAAuC;AA0CvC,MAAa,qBAAsB,SAAQ,sBAAS;IAKlD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiC;QACzE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,yBAAyB;QACzB,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,WAAW,CAAC;QACnD,MAAM,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,IAAI,EAAE,CAAC;QAEtD,MAAM,WAAW,GAAG,IAAI,2CAAmB,CACzC,IAAI,EACJ,0BAA0B,EAC1B;YACE,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE;YAC/B,iBAAiB,EAAE;gBACjB,gBAAgB,EAAE;oBAChB,IAAI,EAAE,MAAM;iBACb;gBACD,aAAa,EAAE;oBACb,OAAO,EAAE,KAAK;oBACd,OAAO,EAAE,IAAI;oBACb,QAAQ,EAAE,IAAI;oBACd,UAAU,EAAE,IAAI;iBACjB;gBACD,cAAc,EAAE;oBACd;wBACE,MAAM,EAAE;4BACN,UAAU,EAAE,UAAU;yBACvB;wBACD,OAAO,EAAE;4BACP,gBAAgB,EAAE,gBAAgB;yBACnC;qBACF;iBACF;gBACD,gBAAgB,EAAE;oBAChB,WAAW,EAAE,sBAAsB;iBACpC;gBACD,yBAAyB,EAAE;oBACzB,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,uBAAuB,EAAE;wBACvB,QAAQ,EAAE,KAAK,CAAC,QAAQ;qBACzB;oBACD,QAAQ,EAAE;wBACR,SAAS;wBACT,kBAAkB;wBAClB,kBAAkB;wBAClB,cAAc;wBACd,aAAa;wBACb,iBAAiB;qBAClB;oBACD,gBAAgB,EAAE,CAAC,mBAAmB,CAAC;oBACvC,gBAAgB,EAAE,EAAE;iBACrB;aACF;SACF,CACF,CAAC;QACF,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAE/B,IAAI,CAAC,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;QAErC,iCAAiC;QACjC,MAAM,YAAY,GAAa,EAAE,CAAC;QAClC,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,cAAc,EAAE;YACzC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SAChC;QAED,wCAAwC;QACxC,WAAW,CAAC,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IACtD,CAAC;;AAzEH,sDA0EC;;;AAED,MAAa,iBAAkB,SAAQ,sBAAS;IAC9C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA6B;QACrE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,iBAAiB,GAAG,IAAI,wDAAyB,CACrD,IAAI,EACJ,0BAA0B,EAC1B;YACE,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE;YAC/B,YAAY,EAAE,KAAK,CAAC,YAAY;SACjC,CACF,CAAC;QAEF,iCAAiC;QACjC,MAAM,YAAY,GAAa,EAAE,CAAC;QAClC,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,cAAc,EAAE;YACzC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SAChC;QAED,wCAAwC;QACxC,iBAAiB,CAAC,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAC5D,CAAC;;AAtBH,8CAuBC","sourcesContent":["import { KeyVaultCertificate } from \"@cdktf/provider-azurerm/lib/key-vault-certificate\"; // Adjust the import path based on the actual module location.\nimport { KeyVaultCertificateIssuer } from \"@cdktf/provider-azurerm/lib/key-vault-certificate-issuer\";\nimport { Construct } from \"constructs\";\nimport { AccessPolicy } from \"./policy\";\nimport { Vault } from \"./vault\";\n\nexport interface SelfSignedCertificateProps {\n  /**\n   * The name of the certificate in the Azure Key Vault.\n   */\n  readonly name: string;\n\n  readonly subject: string;\n\n  readonly dnsNames: string[];\n\n  readonly keyVaultId: Vault;\n\n  readonly actionType?: string;\n\n  readonly daysBeforeExpiry?: number;\n\n  readonly accessPolicies: AccessPolicy[];\n\n  readonly tags?: { [key: string]: string };\n}\n\nexport interface CertificateIssuerProps {\n  /**\n   * The name of the certificate issuer in the Azure Key Vault.\n   */\n  readonly name: string;\n\n  readonly providerName: string;\n\n  readonly keyVaultId: Vault;\n\n  readonly accessPolicies: AccessPolicy[];\n\n  readonly username?: string;\n\n  readonly password?: string;\n}\n\nexport class SelfSignedCertificate extends Construct {\n  public certificate: KeyVaultCertificate;\n  public id: string;\n  public secretId: string;\n\n  constructor(scope: Construct, id: string, props: SelfSignedCertificateProps) {\n    super(scope, id);\n\n    // Provide default values\n    const actionType = props.actionType ?? \"AutoRenew\";\n    const daysBeforeExpiry = props.daysBeforeExpiry ?? 45;\n\n    const certificate = new KeyVaultCertificate(\n      this,\n      \"AzureKeyVaultCertificate\",\n      {\n        name: props.name,\n        keyVaultId: props.keyVaultId.id,\n        certificatePolicy: {\n          issuerParameters: {\n            name: \"Self\",\n          },\n          keyProperties: {\n            keyType: \"RSA\",\n            keySize: 2048,\n            reuseKey: true,\n            exportable: true,\n          },\n          lifetimeAction: [\n            {\n              action: {\n                actionType: actionType,\n              },\n              trigger: {\n                daysBeforeExpiry: daysBeforeExpiry,\n              },\n            },\n          ],\n          secretProperties: {\n            contentType: \"application/x-pkcs12\",\n          },\n          x509CertificateProperties: {\n            subject: props.subject,\n            subjectAlternativeNames: {\n              dnsNames: props.dnsNames,\n            },\n            keyUsage: [\n              \"cRLSign\",\n              \"dataEncipherment\",\n              \"digitalSignature\",\n              \"keyAgreement\",\n              \"keyCertSign\",\n              \"keyEncipherment\",\n            ],\n            extendedKeyUsage: [\"1.3.6.1.5.5.7.3.1\"],\n            validityInMonths: 12,\n          },\n        },\n      },\n    );\n    this.certificate = certificate;\n\n    this.id = certificate.id;\n    this.secretId = certificate.secretId;\n\n    // Accumulate all the fqdn values\n    const dependencies: string[] = [];\n    for (const policy of props.accessPolicies) {\n      dependencies.push(policy.fqdn);\n    }\n\n    // Add dependency on all access policies\n    certificate.addOverride(\"depends_on\", dependencies);\n  }\n}\n\nexport class CertificateIssuer extends Construct {\n  constructor(scope: Construct, id: string, props: CertificateIssuerProps) {\n    super(scope, id);\n\n    const certificateIssuer = new KeyVaultCertificateIssuer(\n      this,\n      \"AzureKeyVaultCertificate\",\n      {\n        name: props.name,\n        keyVaultId: props.keyVaultId.id,\n        providerName: props.providerName,\n      },\n    );\n\n    // Accumulate all the fqdn values\n    const dependencies: string[] = [];\n    for (const policy of props.accessPolicies) {\n      dependencies.push(policy.fqdn);\n    }\n\n    // Add dependency on all access policies\n    certificateIssuer.addOverride(\"depends_on\", dependencies);\n  }\n}\n"]}
+CertificateIssuer[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.CertificateIssuer", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/certificate.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyVaultCertificate } from \"@cdktf/provider-azurerm/lib/key-vault-certificate\"; // Adjust the import path based on the actual module location.\nimport { KeyVaultCertificateIssuer } from \"@cdktf/provider-azurerm/lib/key-vault-certificate-issuer\";\nimport { Construct } from \"constructs\";\nimport { AccessPolicy } from \"./policy\";\nimport { Vault } from \"./vault\";\n\n/**\n * Properties required to create a self-signed certificate within Azure Key Vault.\n */\nexport interface SelfSignedCertificateProps {\n  /**\n   * The name of the certificate to be stored in Azure Key Vault.\n   */\n  readonly name: string;\n\n  /**\n   * The subject name for the certificate, typically represented in X.509 distinguished name format.\n   */\n  readonly subject: string;\n\n  /**\n   * Additional DNS names to be included in the certificate. Useful for creating certificates valid for multiple hostnames.\n   */\n  readonly dnsNames: string[];\n\n  /**\n   * The ID of the Azure Key Vault where the certificate will be created and stored.\n   */\n  readonly keyVaultId: Vault;\n\n  /**\n   * Specifies the type of action to perform with the certificate, such as 'create' or 'renew'.\n   */\n  readonly actionType?: string;\n\n  /**\n   * Specifies the number of days before expiry when an action should be taken (e.g., renew the certificate).\n   */\n  readonly daysBeforeExpiry?: number;\n\n  /**\n   * Access policies defining who can access this certificate within the Azure Key Vault.\n   */\n  readonly accessPolicies: AccessPolicy[];\n\n  /**\n   * Tags to be associated with the certificate for organizational purposes.\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Properties required to configure a certificate issuer within Azure Key Vault.\n */\nexport interface CertificateIssuerProps {\n  /**\n   * The name of the certificate issuer as it will appear in Azure Key Vault.\n   */\n  readonly name: string;\n\n  /**\n   * The name of the provider that will issue the certificate, such as 'DigiCert' or 'GlobalSign'.\n   */\n  readonly providerName: string;\n\n  /**\n   * The ID of the Azure Key Vault where the issuer will be configured.\n   */\n  readonly keyVaultId: Vault;\n\n  /**\n   * Access policies defining who can manage this issuer and the certificates it issues within the Key Vault.\n   */\n  readonly accessPolicies: AccessPolicy[];\n\n  /**\n   * The username required to authenticate with the certificate provider (if applicable).\n   */\n  readonly username?: string;\n\n  /**\n   * The password required to authenticate with the certificate provider (if applicable).\n   */\n  readonly password?: string;\n}\n\nexport class SelfSignedCertificate extends Construct {\n  public certificate: KeyVaultCertificate;\n  public id: string;\n  public secretId: string;\n\n  /**\n   * Constructs a self-signed certificate within an Azure Key Vault.\n   *\n   * This class is responsible for the creation and management of a self-signed certificate, making it available\n   * within an Azure Key Vault. The certificate can be used for testing or internal secure communications.\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 certificate.\n   * @param props - The properties for creating the self-signed certificate as defined in SelfSignedCertificateProps.\n   *\n   * Example usage:\n   * ```typescript\n   * new SelfSignedCertificate(this, 'MySelfSignedCert', {\n   *   name: 'exampleCert',\n   *   subject: 'CN=example.com',\n   *   dnsNames: ['example.com', 'www.example.com'],\n   *   keyVaultId: myKeyVault,\n   *   accessPolicies: [{ userId: 'user123', permissions: ['all'] }],\n   *   tags: { project: 'My Project' }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: SelfSignedCertificateProps) {\n    super(scope, id);\n\n    // Provide default values\n    const actionType = props.actionType ?? \"AutoRenew\";\n    const daysBeforeExpiry = props.daysBeforeExpiry ?? 45;\n\n    const certificate = new KeyVaultCertificate(\n      this,\n      \"AzureKeyVaultCertificate\",\n      {\n        name: props.name,\n        keyVaultId: props.keyVaultId.id,\n        certificatePolicy: {\n          issuerParameters: {\n            name: \"Self\",\n          },\n          keyProperties: {\n            keyType: \"RSA\",\n            keySize: 2048,\n            reuseKey: true,\n            exportable: true,\n          },\n          lifetimeAction: [\n            {\n              action: {\n                actionType: actionType,\n              },\n              trigger: {\n                daysBeforeExpiry: daysBeforeExpiry,\n              },\n            },\n          ],\n          secretProperties: {\n            contentType: \"application/x-pkcs12\",\n          },\n          x509CertificateProperties: {\n            subject: props.subject,\n            subjectAlternativeNames: {\n              dnsNames: props.dnsNames,\n            },\n            keyUsage: [\n              \"cRLSign\",\n              \"dataEncipherment\",\n              \"digitalSignature\",\n              \"keyAgreement\",\n              \"keyCertSign\",\n              \"keyEncipherment\",\n            ],\n            extendedKeyUsage: [\"1.3.6.1.5.5.7.3.1\"],\n            validityInMonths: 12,\n          },\n        },\n      },\n    );\n    this.certificate = certificate;\n\n    this.id = certificate.id;\n    this.secretId = certificate.secretId;\n\n    // Accumulate all the fqdn values\n    const dependencies: string[] = [];\n    for (const policy of props.accessPolicies) {\n      dependencies.push(policy.fqdn);\n    }\n\n    // Add dependency on all access policies\n    certificate.addOverride(\"depends_on\", dependencies);\n  }\n}\n\nexport class CertificateIssuer extends Construct {\n  /**\n   * Constructs a new Certificate Issuer within an Azure Key Vault.\n   *\n   * This class is responsible for setting up a certificate issuer in Azure Key Vault. A certificate issuer is an entity\n   * that issues digital certificates for use in SSL/TLS and other cryptographic security contexts. By configuring an issuer,\n   * you can manage certificate lifecycle (issue, renew, revoke) through Azure Key Vault in conjunction with external certificate\n   * authorities (CAs).\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 certificate issuer.\n   * @param props - The properties for configuring the certificate issuer as defined in CertificateIssuerProps. These properties include:\n   *                - `name`: Required. The name of the issuer as it will appear in Azure Key Vault.\n   *                - `providerName`: Required. The name of the provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.\n   *                - `keyVaultId`: Required. The ID of the Azure Key Vault where the issuer will be configured.\n   *                - `accessPolicies`: Required. Access policies defining who can manage this issuer within the Key Vault.\n   *                - `username`: Optional. The username required to authenticate with the certificate provider (if applicable).\n   *                - `password`: Optional. The password required to authenticate with the certificate provider (if applicable).\n   *\n   * Example usage:\n   * ```typescript\n   * new CertificateIssuer(this, 'MyCertIssuer', {\n   *   name: 'MyIssuer',\n   *   providerName: 'DigiCert',\n   *   keyVaultId: myKeyVault,\n   *   accessPolicies: [{ userId: 'user123', permissions: ['manageIssuer'] }],\n   *   username: 'user@example.com',\n   *   password: 'securepassword'\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: CertificateIssuerProps) {\n    super(scope, id);\n\n    const certificateIssuer = new KeyVaultCertificateIssuer(\n      this,\n      \"AzureKeyVaultCertificate\",\n      {\n        name: props.name,\n        keyVaultId: props.keyVaultId.id,\n        providerName: props.providerName,\n      },\n    );\n\n    // Accumulate all the fqdn values\n    const dependencies: string[] = [];\n    for (const policy of props.accessPolicies) {\n      dependencies.push(policy.fqdn);\n    }\n\n    // Add dependency on all access policies\n    certificateIssuer.addOverride(\"depends_on\", dependencies);\n  }\n}\n"]}

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

@@ -32,5 +32,41 @@ export interface KeyProps {
 }
 export declare class Key extends Construct {
     vaultKey: KeyVaultKey;
+    /**
+     * Constructs a new Key resource in Azure Key Vault.
+     *
+     * This class is responsible for the creation and management of a cryptographic key stored in Azure Key Vault.
+     * The key can be used for a variety of cryptographic operations, such as encryption, decryption, signing, or
+     * verifying signatures, depending on the permissions granted. It supports different key types and configurations,
+     * allowing for customization to meet specific security requirements.
+     *
+     * @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.
+     * @param props - The properties for creating the key as defined in KeyProps. These properties include:
+     *                - `name`: Required. The name of the key as it will appear in Azure Key Vault.
+     *                - `keyVaultId`: Required. The ID of the Azure Key Vault where the key will be created.
+     *                - `keyType`: Required. The type of cryptographic key to create (e.g., RSA, EC).
+     *                - `keySize`: Optional. The size of the key, typically specified for RSA keys.
+     *                - `keyOpts`: Optional. Additional options or attributes related to the key's capabilities such as encrypt, decrypt, wrapKey, unwrapKey.
+     *                - `rotationPolicy`: Optional. The policy settings for rotating the key automatically.
+     *                - `expires`: Optional. The expiration date of the key in UTC format (YYYY-MM-DDTHH:MM:SSZ).
+     *                - `accessPolicies`: Required. Access policies defining who can access this key within the Key Vault.
+     *
+     * Example usage:
+     * ```typescript
+     * new Key(this, 'myKey', {
+     *   name: 'encryptionKey',
+     *   keyVaultId: myKeyVault,
+     *   keyType: 'RSA',
+     *   keySize: 2048,
+     *   keyOpts: ['encrypt', 'decrypt', 'sign', 'verify'],
+     *   rotationPolicy: {
+     *     expiryTime: 'P90D'
+     *   },
+     *   expires: '2030-01-01T00:00:00Z',
+     *   accessPolicies: [{ userId: 'user123', permissions: ['get', 'list', 'update'] }]
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: KeyProps);
 }

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

@@ -6,6 +6,42 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const key_vault_key_1 = require("@cdktf/provider-azurerm/lib/key-vault-key");
 const constructs_1 = require("constructs");
 class Key extends constructs_1.Construct {
+    /**
+     * Constructs a new Key resource in Azure Key Vault.
+     *
+     * This class is responsible for the creation and management of a cryptographic key stored in Azure Key Vault.
+     * The key can be used for a variety of cryptographic operations, such as encryption, decryption, signing, or
+     * verifying signatures, depending on the permissions granted. It supports different key types and configurations,
+     * allowing for customization to meet specific security requirements.
+     *
+     * @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.
+     * @param props - The properties for creating the key as defined in KeyProps. These properties include:
+     *                - `name`: Required. The name of the key as it will appear in Azure Key Vault.
+     *                - `keyVaultId`: Required. The ID of the Azure Key Vault where the key will be created.
+     *                - `keyType`: Required. The type of cryptographic key to create (e.g., RSA, EC).
+     *                - `keySize`: Optional. The size of the key, typically specified for RSA keys.
+     *                - `keyOpts`: Optional. Additional options or attributes related to the key's capabilities such as encrypt, decrypt, wrapKey, unwrapKey.
+     *                - `rotationPolicy`: Optional. The policy settings for rotating the key automatically.
+     *                - `expires`: Optional. The expiration date of the key in UTC format (YYYY-MM-DDTHH:MM:SSZ).
+     *                - `accessPolicies`: Required. Access policies defining who can access this key within the Key Vault.
+     *
+     * Example usage:
+     * ```typescript
+     * new Key(this, 'myKey', {
+     *   name: 'encryptionKey',
+     *   keyVaultId: myKeyVault,
+     *   keyType: 'RSA',
+     *   keySize: 2048,
+     *   keyOpts: ['encrypt', 'decrypt', 'sign', 'verify'],
+     *   rotationPolicy: {
+     *     expiryTime: 'P90D'
+     *   },
+     *   expires: '2030-01-01T00:00:00Z',
+     *   accessPolicies: [{ userId: 'user123', permissions: ['get', 'list', 'update'] }]
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         const key = new key_vault_key_1.KeyVaultKey(this, "AzureKeyVaultKey", {
@@ -29,5 +65,5 @@ class Key extends constructs_1.Construct {
 }
 exports.Key = Key;
 _a = JSII_RTTI_SYMBOL_1;
-Key[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.Key", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,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
+Key[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.Key", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-keyvault/lib/policy.d.ts

@@ -42,5 +42,35 @@ export interface AccessPolicyProps {
 }
 export declare class AccessPolicy extends Construct {
     readonly fqdn: string;
+    /**
+     * Constructs a new Access Policy for Azure Key Vault.
+     *
+     * This class is responsible for setting up access policies that define what operations an Azure AD identity
+     * can perform on the keys, secrets, certificates, and storage accounts within a specified Azure Key Vault.
+     *
+     * @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 access policy.
+     * @param props - The properties for creating the access policy as defined in AccessPolicyProps. These include:
+     *                - `keyVaultId`: The Azure Key Vault identifier where the policy will be set.
+     *                - `tenantId`: The tenant ID of the Azure AD tenant where the Key Vault is hosted.
+     *                - `objectId`: The object ID of the Azure AD identity (user, group, or service principal).
+     *                - `secretPermissions`: Optional list of permissions to secrets within the Key Vault.
+     *                - `certificatePermissions`: Optional list of permissions to certificates within the Key Vault.
+     *                - `keyPermissions`: Optional list of permissions to keys within the Key Vault.
+     *                - `storagePermissions`: Optional list of permissions to storage accounts linked to the Key Vault.
+     *
+     * Example usage:
+     * ```typescript
+     * new AccessPolicy(this, 'MyAccessPolicy', {
+     *   keyVaultId: myKeyVault,
+     *   tenantId: 'my-tenant-id',
+     *   objectId: 'user-object-id',
+     *   keyPermissions: ['get', 'list', 'update'],
+     *   secretPermissions: ['get'],
+     *   certificatePermissions: ['get', 'list'],
+     *   storagePermissions: ['get', 'list']
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: AccessPolicyProps);
 }

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

@@ -6,6 +6,36 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const key_vault_access_policy_1 = require("@cdktf/provider-azurerm/lib/key-vault-access-policy");
 const constructs_1 = require("constructs");
 class AccessPolicy extends constructs_1.Construct {
+    /**
+     * Constructs a new Access Policy for Azure Key Vault.
+     *
+     * This class is responsible for setting up access policies that define what operations an Azure AD identity
+     * can perform on the keys, secrets, certificates, and storage accounts within a specified Azure Key Vault.
+     *
+     * @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 access policy.
+     * @param props - The properties for creating the access policy as defined in AccessPolicyProps. These include:
+     *                - `keyVaultId`: The Azure Key Vault identifier where the policy will be set.
+     *                - `tenantId`: The tenant ID of the Azure AD tenant where the Key Vault is hosted.
+     *                - `objectId`: The object ID of the Azure AD identity (user, group, or service principal).
+     *                - `secretPermissions`: Optional list of permissions to secrets within the Key Vault.
+     *                - `certificatePermissions`: Optional list of permissions to certificates within the Key Vault.
+     *                - `keyPermissions`: Optional list of permissions to keys within the Key Vault.
+     *                - `storagePermissions`: Optional list of permissions to storage accounts linked to the Key Vault.
+     *
+     * Example usage:
+     * ```typescript
+     * new AccessPolicy(this, 'MyAccessPolicy', {
+     *   keyVaultId: myKeyVault,
+     *   tenantId: 'my-tenant-id',
+     *   objectId: 'user-object-id',
+     *   keyPermissions: ['get', 'list', 'update'],
+     *   secretPermissions: ['get'],
+     *   certificatePermissions: ['get', 'list'],
+     *   storagePermissions: ['get', 'list']
+     * });
+     * ```
+     */
     constructor(scope, id, props) {
         super(scope, id);
         const policy = new key_vault_access_policy_1.KeyVaultAccessPolicyA(this, "policy", {
@@ -22,5 +52,5 @@ class AccessPolicy extends constructs_1.Construct {
 }
 exports.AccessPolicy = AccessPolicy;
 _a = JSII_RTTI_SYMBOL_1;
-AccessPolicy[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.AccessPolicy", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,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
+AccessPolicy[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.AccessPolicy", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-keyvault/lib/secret.d.ts

@@ -35,5 +35,36 @@ export interface SecretProps {
 }
 export declare class Secret extends Construct {
     secretId: string;
+    /**
+     * Constructs a new Azure Key Vault Secret within a specified Key Vault.
+     *
+     * This class facilitates the creation and management of a secret, allowing sensitive information to be stored securely
+     * and accessed as needed while maintaining confidentiality and control through defined access policies.
+     *
+     * @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 secret.
+     * @param props - The properties for creating the secret as defined in SecretProps. These include:
+     *                - `keyVaultId`: The ID of the Key Vault in which to store the secret.
+     *                - `name`: The name of the secret.
+     *                - `value`: The confidential data to be stored as the secret.
+     *                - `expirationDate`: Optional. The expiration date of the secret.
+     *                - `contentType`: Optional. A label hinting at the content type of the secret's value.
+     *                - `accessPolicies`: Access policies that dictate permissions for the secret.
+     *
+     * Example usage:
+     * ```typescript
+     * new Secret(this, 'mySecret', {
+     *   keyVaultId: myKeyVault,
+     *   name: 'dbPassword',
+     *   value: 'p@ssw0rd!',
+     *   expirationDate: '2030-01-01T00:00:00Z',
+     *   contentType: 'password',
+     *   accessPolicies: [{
+     *     objectId: '12345-user-object-id',
+     *     permissions: ['get', 'list']
+     *   }]
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, props: SecretProps);
 }