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

package/lib/azure-storageaccount/lib/account.js

@@ -10,29 +10,41 @@ const fileshare_1 = require("./fileshare");
 const queue_1 = require("./queue");
 const table_1 = require("./table");
 const lib_1 = require("../../core-azure/lib");
-/**
- * Represents an Azure Storage Account within a Terraform deployment.
- * This class provides methods to easily manage storage resources such as Containers,
- * File Shares, Tables, Queues, and Network Rules.
- *
- * Example usage:
- * ```typescript
- * const storageAccount = new AzureStorageAccount(this, 'storageaccount', {
- *   name: 'myStorageAccount',
- *   location: 'East US',
- *   resourceGroup: myResourceGroup,
- *   accountReplicationType: 'LRS',
- *   accountTier: 'Standard',
- *   // other properties
- * });
- * ```
- */
 class Account extends lib_1.AzureResourceWithAlert {
     /**
-     * Initializes a new AzureStorageAccount.
-     * @param scope The scope in which to define this construct.
-     * @param id The scoped construct ID.
-     * @param props Configuration properties for the Azure Storage Account.
+     * Represents an Azure Storage Account within a Terraform deployment.
+     *
+     * This class is responsible for the creation and management of an Azure Storage Account, which is a scalable and secure service
+     * for storing large amounts of unstructured data that can be accessed from anywhere in the world over HTTP or HTTPS. Common uses
+     * of the Azure Storage Account include storing of blobs (objects), file shares, tables, and queues. This class provides methods
+     * to manage storage resources, configure network rules, and integrate with Azure Active Directory for secure access management.
+     *
+     * @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 storage account.
+     * @param props - The properties required to configure the Azure Storage Account, as defined in the AccountProps interface. These include:
+     *                - `name`: The name of the storage account, which must be unique within the Azure region.
+     *                - `location`: The Azure region where the storage account will be created.
+     *                - `resourceGroup`: The Azure Resource Group under which the storage account will be deployed.
+     *                - `accountReplicationType`: The type of data replication to ensure data durability and availability.
+     *                - `accountTier`: The performance tier that affects the type of hardware used for the storage account.
+     *                - `tags`: A dictionary of tags to apply to the storage account for organizational purposes.
+     *
+     * Example usage:
+     * ```typescript
+     * const storageAccount = new Account(this, 'MyStorageAccount', {
+     *   location: 'East US',
+     *   name: 'myStorageAccount',
+     *   resourceGroup: myResourceGroup,
+     *   accountReplicationType: 'LRS',
+     *   accountTier: 'Standard',
+     *   enableHttpsTrafficOnly: true,
+     *   tags: {
+     *     environment: 'production'
+     *   }
+     * });
+     * ```
+     * This class sets up the storage account with the specified configurations, handles resource allocation, and applies security
+     * settings based on the properties provided.
      */
     constructor(scope, id, props) {
         super(scope, id);
@@ -69,15 +81,18 @@ class Account extends lib_1.AzureResourceWithAlert {
     }
     /**
      * Adds a new container to the storage account.
-     * @param name The name of the container.
-     * @param containerAccessType The access type of the container (e.g., 'blob', 'private').
-     * @param metadata Metadata for the container.
-     * @returns The created AzureStorageContainer.
-     * @throws Error if a container with the same name already exists.
+     * @param name The name of the container. It must be unique within the storage account.
+     * @param containerAccessType The level of public access to the container. Defaults to 'private'.
+     * @param metadata Optional metadata for the container as key-value pairs.
+     * @returns The created Container instance.
+     * @throws Error if a container with the same name already exists within the storage account.
+     *
+     * This method creates a new container within the Azure storage account, allowing for the specification of access
+     * level and metadata. If the container already exists, it throws an error to prevent duplication.
      *
      * Example usage:
      * ```typescript
-     * const container = storageAccount.addContainer('myContainer', 'private');
+     * const container = storageAccount.addContainer('myContainer', 'private', { owner: 'IT' });
      * ```
      */
     addContainer(name, containerAccessType, metadata) {
@@ -95,14 +110,17 @@ class Account extends lib_1.AzureResourceWithAlert {
     }
     /**
      * Adds a new file share to the storage account.
-     * @param name The name of the file share.
-     * @param props Optional properties for the file share (e.g., quota, access tier).
-     * @returns The created AzureStorageShare.
-     * @throws Error if a share with the same name already exists.
+     * @param name The name of the file share. Must be unique within the storage account.
+     * @param props Optional properties for configuring the file share, such as quota and access tier.
+     * @returns The created FileShare instance.
+     * @throws Error if a file share with the same name already exists.
+     *
+     * This method facilitates the addition of a file share to the storage account, with optional settings for
+     * capacity (quota) and data access frequency (access tier). If a file share with the same name exists, an error is thrown.
      *
      * Example usage:
      * ```typescript
-     * const fileShare = storageAccount.addShare('myFileShare', { quota: 1024, accessTier: 'Hot' });
+     * const fileShare = storageAccount.addFileShare('myFileShare', { quota: 1024, accessTier: 'Hot' });
      * ```
      */
     addFileShare(name, props) {
@@ -126,14 +144,17 @@ class Account extends lib_1.AzureResourceWithAlert {
     }
     /**
      * Adds a new table to the storage account.
-     * @param name The name of the table.
-     * @param acl Optional access control list for the table.
-     * @returns The created AzureStorageTable.
+     * @param name The name of the table. Must be unique within the storage account.
+     * @param acl Optional access control list for the table, specifying permissions.
+     * @returns The created Table instance.
      * @throws Error if a table with the same name already exists.
      *
+     * This method creates a new table within the storage account, optionally allowing for access control configurations.
+     * It throws an error if a table with the same name already exists, ensuring uniqueness within the account.
+     *
      * Example usage:
      * ```typescript
-     * const table = storageAccount.addTable('myTable');
+     * const table = storageAccount.addTable('myTable', [{ id: 'policy1', type: 'read' }]);
      * ```
      */
     addTable(name, acl) {
@@ -150,13 +171,16 @@ class Account extends lib_1.AzureResourceWithAlert {
     }
     /**
      * Adds a new queue to the storage account.
-     * @param name The name of the queue.
-     * @param metadata Optional metadata for the queue.
-     * @returns The created AzureStorageQueue.
+     * @param name The name of the queue. Must be unique within the storage account.
+     * @param metadata Optional metadata for the queue as key-value pairs.
+     * @returns The created Queue instance.
+     *
+     * This method creates a new queue in the storage account, with optional metadata. It is useful for message queuing
+     * in applications, enabling asynchronous task processing and inter-service communication.
      *
      * Example usage:
      * ```typescript
-     * const queue = storageAccount.addQueue('myQueue');
+     * const queue = storageAccount.addQueue('myQueue', { priority: 'high' });
      * ```
      */
     addQueue(name, metadata) {
@@ -167,18 +191,21 @@ class Account extends lib_1.AzureResourceWithAlert {
         });
     }
     /**
-     * Adds network rules to the storage account.
-     * @param props Configuration properties for the network rules.
-     * @returns The configured StorageAccountNetworkRulesA.
+     * Adds network rules to the storage account to control access based on IP and virtual network settings.
+     * @param props Configuration properties for the network rules, including allowed IPs and virtual network subnet IDs.
+     * @returns The configured network rules.
+     *
+     * This method configures network rules for the storage account, specifying which IPs and virtual networks can access
+     * the storage resources. It allows detailed control over data security and access management.
      *
      * Example usage:
      * ```typescript
      * storageAccount.addNetworkRules({
-     *     bypass: ['AzureServices'],
-     *     defaultAction: 'Deny',
-     *     ipRules: ['1.2.3.4/32'],
-     *     virtualNetworkSubnetIds: ['subnetId'],
-     *  });
+     *   bypass: ['AzureServices'],
+     *   defaultAction: 'Deny',
+     *   ipRules: ['1.2.3.4/32'],
+     *   virtualNetworkSubnetIds: ['subnetId'],
+     * });
      * ```
      */
     addNetworkRules(props) {
@@ -194,5 +221,5 @@ class Account extends lib_1.AzureResourceWithAlert {
 }
 exports.Account = Account;
 _a = JSII_RTTI_SYMBOL_1;
-Account[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Account", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account.js","sourceRoot":"","sources":["../../../src/azure-storageaccount/lib/account.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { StorageAccount } from \"@cdktf/provider-azurerm/lib/storage-account\";\nimport {\n  StorageAccountNetworkRulesA,\n  StorageAccountNetworkRulesPrivateLinkAccessA,\n} from \"@cdktf/provider-azurerm/lib/storage-account-network-rules\";\nimport { StorageTableAcl } from \"@cdktf/provider-azurerm/lib/storage-table\";\nimport { Construct } from \"constructs\";\nimport { Container } from \"./container\";\nimport { FileShare, FileShareProps } from \"./fileshare\";\nimport { Queue } from \"./queue\";\nimport { Table } from \"./table\";\nimport { AzureResourceWithAlert } from \"../../core-azure/lib\";\n\nexport interface NetworkRulesProps {\n  /**\n   * Specifies which traffic to bypass from the network rules. The possible values are 'AzureServices', 'Logging', 'Metrics',\n   * and 'None'. Bypassing 'AzureServices' enables Azure's internal services to access the storage account.\n   */\n  readonly bypass?: string[];\n\n  /**\n   * The default action of the network rule set. Options are 'Allow' or 'Deny'. Set to 'Deny' to enable network rules and restrict\n   * access to the storage account. 'Allow' permits access by default.\n   */\n  readonly defaultAction: string;\n\n  /**\n   * An array of IP rules to allow access to the storage account. These are specified as CIDR ranges.\n   * Example: ['1.2.3.4/32', '5.6.7.0/24'] to allow specific IPs/subnets.\n   */\n  readonly ipRules?: string[];\n\n  /**\n   * An array of virtual network subnet IDs that are allowed to access the storage account. This enables you to secure the storage\n   * account to a specific virtual network and subnet within Azure.\n   */\n  readonly virtualNetworkSubnetIds?: string[];\n\n  /**\n   * An array of objects representing the private link access settings. Each object in the array defines the sub-resource name\n   * (e.g., 'blob', 'file') and its respective private endpoint connections for the storage account.\n   */\n  readonly privateLinkAccess?: StorageAccountNetworkRulesPrivateLinkAccessA[];\n}\n\nexport interface AccountProps {\n  /**\n   * The type of replication to use for the storage account. This determines how your data is replicated across Azure's infrastructure.\n   * Example values: LRS (Locally Redundant Storage), GRS (Geo-Redundant Storage), RAGRS (Read Access Geo-Redundant Storage).\n   */\n  readonly accountReplicationType?: string;\n\n  /**\n   * The performance tier of the storage account. Determines the type of hardware and performance level.\n   * Example values: Standard, Premium.\n   */\n  readonly accountTier?: string;\n\n  /**\n   * The Azure region in which to create the storage account.\n   */\n  readonly location: string;\n\n  /**\n   * The name of the storage account. Must be unique across Azure.\n   */\n  readonly name: string;\n\n  /**\n   * The name of the Azure resource group in which to create the storage account.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * Tags to apply to the storage account, used for categorization and billing purposes.\n   * Format: { [key: string]: string }\n   */\n  readonly tags?: { readonly [key: string]: string };\n\n  /**\n   * A boolean flag indicating whether to enforce HTTPS for data transfer to the storage account.\n   */\n  readonly enableHttpsTrafficOnly?: boolean;\n\n  /**\n   * Managed Service Identity (MSI) details. Used for enabling and managing Azure Active Directory (AAD) authentication.\n   */\n  readonly identity?: any; // Replace 'any' with a more specific type if available.\n\n  /**\n   * The data access tier of the storage account, which impacts storage costs and data retrieval speeds.\n   * Example values: Hot, Cool.\n   */\n  readonly accessTier?: string;\n\n  /**\n   * A flag indicating whether the Hierarchical Namespace (HNS) is enabled, which is required for Azure Data Lake Storage Gen2 features.\n   */\n  readonly isHnsEnabled?: boolean;\n\n  /**\n   * The minimum TLS version to be used for securing connections to the storage account.\n   * Example values: TLS1_0, TLS1_1, TLS1_2.\n   */\n  readonly minTlsVersion?: string;\n\n  /**\n   * A boolean flag indicating whether public network access to the storage account is allowed.\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/azurerm/3.92.0/docs/resources/storage_account#account_kind StorageAccount#account_kind}\n   */\n  readonly accountKind?: string;\n}\n\n/**\n * Represents an Azure Storage Account within a Terraform deployment.\n * This class provides methods to easily manage storage resources such as Containers,\n * File Shares, Tables, Queues, and Network Rules.\n *\n * Example usage:\n * ```typescript\n * const storageAccount = new AzureStorageAccount(this, 'storageaccount', {\n *   name: 'myStorageAccount',\n *   location: 'East US',\n *   resourceGroup: myResourceGroup,\n *   accountReplicationType: 'LRS',\n *   accountTier: 'Standard',\n *   // other properties\n * });\n * ```\n */\nexport class Account extends AzureResourceWithAlert {\n  public readonly props: AccountProps;\n  public id: string;\n  public readonly name: string;\n  public readonly location: string;\n  public resourceGroup: ResourceGroup;\n  public readonly accountKind: string;\n  public readonly accountTier: string;\n  private readonly containers: Map<string, Container>;\n  private readonly shares: Map<string, FileShare>;\n  private readonly tables: Map<string, Table>;\n\n  /**\n   * Initializes a new AzureStorageAccount.\n   * @param scope The scope in which to define this construct.\n   * @param id The scoped construct ID.\n   * @param props Configuration properties for the Azure Storage Account.\n   */\n  constructor(scope: Construct, id: string, props: AccountProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = this.setupResourceGroup(props);\n    this.containers = new Map<string, Container>();\n    this.shares = new Map<string, FileShare>();\n    this.tables = new Map<string, Table>();\n    this.name = props.name;\n    this.location = props.location;\n\n    // default Storage Account Settings\n    const defaults = {\n      accountReplicationType: \"LRS\",\n      accountTier: \"Standard\",\n      enableHttpsTrafficOnly: true,\n      accessTier: \"Hot\",\n      isHnsEnabled: true,\n      minTlsVersion: \"TLS1_2\",\n      publicnetworkAccessEnabled: false,\n      ...props,\n    };\n\n    // Create the storage account\n    const storageAccount = new StorageAccount(this, \"storageaccount\", {\n      ...defaults,\n      name: props.name,\n      resourceGroupName: this.resourceGroup.name,\n      location: props.location,\n      tags: props.tags,\n    });\n\n    this.id = storageAccount.id;\n    this.name = storageAccount.name;\n    this.accountKind = storageAccount.accountKind;\n    this.accountTier = storageAccount.accountTier;\n  }\n\n  /**\n   * Adds a new container to the storage account.\n   * @param name The name of the container.\n   * @param containerAccessType The access type of the container (e.g., 'blob', 'private').\n   * @param metadata Metadata for the container.\n   * @returns The created AzureStorageContainer.\n   * @throws Error if a container with the same name already exists.\n   *\n   * Example usage:\n   * ```typescript\n   * const container = storageAccount.addContainer('myContainer', 'private');\n   * ```\n   */\n  public addContainer(\n    name: string,\n    containerAccessType?: string,\n    metadata?: { [key: string]: string },\n  ): Container {\n    if (this.containers.has(name)) {\n      throw new Error(`Container '${name}' already exists.`);\n    }\n\n    const newContainer = new Container(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      containerAccessType: containerAccessType || \"private\",\n      metadata: metadata || {},\n    });\n\n    this.containers.set(name, newContainer);\n    return newContainer;\n  }\n\n  /**\n   * Adds a new file share to the storage account.\n   * @param name The name of the file share.\n   * @param props Optional properties for the file share (e.g., quota, access tier).\n   * @returns The created AzureStorageShare.\n   * @throws Error if a share with the same name already exists.\n   *\n   * Example usage:\n   * ```typescript\n   * const fileShare = storageAccount.addShare('myFileShare', { quota: 1024, accessTier: 'Hot' });\n   * ```\n   */\n  public addFileShare(name: string, props?: FileShareProps): FileShare {\n    if (this.shares.has(name)) {\n      throw new Error(`Share '${name}' already exists.`);\n    }\n\n    const defaults = {\n      quota: props?.quota || 1024,\n      accessTier: props?.accessTier || \"Hot\",\n      enabledProtocol: props?.enabledProtocol || \"SMB\",\n      acl: props?.acl || [],\n      metadata: props?.metadata || {},\n    };\n\n    const newShare = new FileShare(this, name, {\n      ...defaults,\n      name: name,\n      storageAccountName: this.name,\n    });\n\n    this.shares.set(name, newShare);\n    return newShare;\n  }\n\n  /**\n   * Adds a new table to the storage account.\n   * @param name The name of the table.\n   * @param acl Optional access control list for the table.\n   * @returns The created AzureStorageTable.\n   * @throws Error if a table with the same name already exists.\n   *\n   * Example usage:\n   * ```typescript\n   * const table = storageAccount.addTable('myTable');\n   * ```\n   */\n  public addTable(name: string, acl?: StorageTableAcl[]): Table {\n    if (this.tables.has(name)) {\n      throw new Error(`Table '${name}' already exists.`);\n    }\n\n    const newTable = new Table(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      acl: acl,\n    });\n\n    this.tables.set(name, newTable);\n    return newTable;\n  }\n\n  /**\n   * Adds a new queue to the storage account.\n   * @param name The name of the queue.\n   * @param metadata Optional metadata for the queue.\n   * @returns The created AzureStorageQueue.\n   *\n   * Example usage:\n   * ```typescript\n   * const queue = storageAccount.addQueue('myQueue');\n   * ```\n   */\n  public addQueue(name: string, metadata?: { [key: string]: string }): Queue {\n    return new Queue(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      metadata: metadata,\n    });\n  }\n\n  /**\n   * Adds network rules to the storage account.\n   * @param props Configuration properties for the network rules.\n   * @returns The configured StorageAccountNetworkRulesA.\n   *\n   * Example usage:\n   * ```typescript\n   * storageAccount.addNetworkRules({\n   *     bypass: ['AzureServices'],\n   *     defaultAction: 'Deny',\n   *     ipRules: ['1.2.3.4/32'],\n   *     virtualNetworkSubnetIds: ['subnetId'],\n   *  });\n   * ```\n   */\n  public addNetworkRules(\n    props: NetworkRulesProps,\n  ): StorageAccountNetworkRulesA {\n    return new StorageAccountNetworkRulesA(this, \"rules\", {\n      storageAccountId: this.id,\n      bypass: props.bypass,\n      defaultAction: props.defaultAction,\n      ipRules: props.ipRules,\n      virtualNetworkSubnetIds: props.virtualNetworkSubnetIds,\n      privateLinkAccess: props.privateLinkAccess,\n    });\n  }\n}\n"]}
+Account[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Account", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account.js","sourceRoot":"","sources":["../../../src/azure-storageaccount/lib/account.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { StorageAccount } from \"@cdktf/provider-azurerm/lib/storage-account\";\nimport {\n  StorageAccountNetworkRulesA,\n  StorageAccountNetworkRulesPrivateLinkAccessA,\n} from \"@cdktf/provider-azurerm/lib/storage-account-network-rules\";\nimport { StorageTableAcl } from \"@cdktf/provider-azurerm/lib/storage-table\";\nimport { Construct } from \"constructs\";\nimport { Container } from \"./container\";\nimport { FileShare, FileShareProps } from \"./fileshare\";\nimport { Queue } from \"./queue\";\nimport { Table } from \"./table\";\nimport { AzureResourceWithAlert } from \"../../core-azure/lib\";\n\nexport interface NetworkRulesProps {\n  /**\n   * Specifies which traffic to bypass from the network rules. The possible values are 'AzureServices', 'Logging', 'Metrics',\n   * and 'None'. Bypassing 'AzureServices' enables Azure's internal services to access the storage account.\n   */\n  readonly bypass?: string[];\n\n  /**\n   * The default action of the network rule set. Options are 'Allow' or 'Deny'. Set to 'Deny' to enable network rules and restrict\n   * access to the storage account. 'Allow' permits access by default.\n   */\n  readonly defaultAction: string;\n\n  /**\n   * An array of IP rules to allow access to the storage account. These are specified as CIDR ranges.\n   * Example: ['1.2.3.4/32', '5.6.7.0/24'] to allow specific IPs/subnets.\n   */\n  readonly ipRules?: string[];\n\n  /**\n   * An array of virtual network subnet IDs that are allowed to access the storage account. This enables you to secure the storage\n   * account to a specific virtual network and subnet within Azure.\n   */\n  readonly virtualNetworkSubnetIds?: string[];\n\n  /**\n   * An array of objects representing the private link access settings. Each object in the array defines the sub-resource name\n   * (e.g., 'blob', 'file') and its respective private endpoint connections for the storage account.\n   */\n  readonly privateLinkAccess?: StorageAccountNetworkRulesPrivateLinkAccessA[];\n}\n\nexport interface AccountProps {\n  /**\n   * The type of replication to use for the storage account. This determines how your data is replicated across Azure's infrastructure.\n   * Example values: LRS (Locally Redundant Storage), GRS (Geo-Redundant Storage), RAGRS (Read Access Geo-Redundant Storage).\n   */\n  readonly accountReplicationType?: string;\n\n  /**\n   * The performance tier of the storage account. Determines the type of hardware and performance level.\n   * Example values: Standard, Premium.\n   */\n  readonly accountTier?: string;\n\n  /**\n   * The Azure region in which to create the storage account.\n   */\n  readonly location: string;\n\n  /**\n   * The name of the storage account. Must be unique across Azure.\n   */\n  readonly name: string;\n\n  /**\n   * The name of the Azure resource group in which to create the storage account.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * Tags to apply to the storage account, used for categorization and billing purposes.\n   * Format: { [key: string]: string }\n   */\n  readonly tags?: { readonly [key: string]: string };\n\n  /**\n   * A boolean flag indicating whether to enforce HTTPS for data transfer to the storage account.\n   */\n  readonly enableHttpsTrafficOnly?: boolean;\n\n  /**\n   * Managed Service Identity (MSI) details. Used for enabling and managing Azure Active Directory (AAD) authentication.\n   */\n  readonly identity?: any; // Replace 'any' with a more specific type if available.\n\n  /**\n   * The data access tier of the storage account, which impacts storage costs and data retrieval speeds.\n   * Example values: Hot, Cool.\n   */\n  readonly accessTier?: string;\n\n  /**\n   * A flag indicating whether the Hierarchical Namespace (HNS) is enabled, which is required for Azure Data Lake Storage Gen2 features.\n   */\n  readonly isHnsEnabled?: boolean;\n\n  /**\n   * The minimum TLS version to be used for securing connections to the storage account.\n   * Example values: TLS1_0, TLS1_1, TLS1_2.\n   */\n  readonly minTlsVersion?: string;\n\n  /**\n   * A boolean flag indicating whether public network access to the storage account is allowed.\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/azurerm/3.92.0/docs/resources/storage_account#account_kind StorageAccount#account_kind}\n   */\n  readonly accountKind?: string;\n}\n\nexport class Account extends AzureResourceWithAlert {\n  public readonly props: AccountProps;\n  public id: string;\n  public readonly name: string;\n  public readonly location: string;\n  public resourceGroup: ResourceGroup;\n  public readonly accountKind: string;\n  public readonly accountTier: string;\n  private readonly containers: Map<string, Container>;\n  private readonly shares: Map<string, FileShare>;\n  private readonly tables: Map<string, Table>;\n\n  /**\n   * Represents an Azure Storage Account within a Terraform deployment.\n   *\n   * This class is responsible for the creation and management of an Azure Storage Account, which is a scalable and secure service\n   * for storing large amounts of unstructured data that can be accessed from anywhere in the world over HTTP or HTTPS. Common uses\n   * of the Azure Storage Account include storing of blobs (objects), file shares, tables, and queues. This class provides methods\n   * to manage storage resources, configure network rules, and integrate with Azure Active Directory for secure access management.\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 storage account.\n   * @param props - The properties required to configure the Azure Storage Account, as defined in the AccountProps interface. These include:\n   *                - `name`: The name of the storage account, which must be unique within the Azure region.\n   *                - `location`: The Azure region where the storage account will be created.\n   *                - `resourceGroup`: The Azure Resource Group under which the storage account will be deployed.\n   *                - `accountReplicationType`: The type of data replication to ensure data durability and availability.\n   *                - `accountTier`: The performance tier that affects the type of hardware used for the storage account.\n   *                - `tags`: A dictionary of tags to apply to the storage account for organizational purposes.\n   *\n   * Example usage:\n   * ```typescript\n   * const storageAccount = new Account(this, 'MyStorageAccount', {\n   *   location: 'East US',\n   *   name: 'myStorageAccount',\n   *   resourceGroup: myResourceGroup,\n   *   accountReplicationType: 'LRS',\n   *   accountTier: 'Standard',\n   *   enableHttpsTrafficOnly: true,\n   *   tags: {\n   *     environment: 'production'\n   *   }\n   * });\n   * ```\n   * This class sets up the storage account with the specified configurations, handles resource allocation, and applies security\n   * settings based on the properties provided.\n   */\n  constructor(scope: Construct, id: string, props: AccountProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = this.setupResourceGroup(props);\n    this.containers = new Map<string, Container>();\n    this.shares = new Map<string, FileShare>();\n    this.tables = new Map<string, Table>();\n    this.name = props.name;\n    this.location = props.location;\n\n    // default Storage Account Settings\n    const defaults = {\n      accountReplicationType: \"LRS\",\n      accountTier: \"Standard\",\n      enableHttpsTrafficOnly: true,\n      accessTier: \"Hot\",\n      isHnsEnabled: true,\n      minTlsVersion: \"TLS1_2\",\n      publicnetworkAccessEnabled: false,\n      ...props,\n    };\n\n    // Create the storage account\n    const storageAccount = new StorageAccount(this, \"storageaccount\", {\n      ...defaults,\n      name: props.name,\n      resourceGroupName: this.resourceGroup.name,\n      location: props.location,\n      tags: props.tags,\n    });\n\n    this.id = storageAccount.id;\n    this.name = storageAccount.name;\n    this.accountKind = storageAccount.accountKind;\n    this.accountTier = storageAccount.accountTier;\n  }\n\n  /**\n   * Adds a new container to the storage account.\n   * @param name The name of the container. It must be unique within the storage account.\n   * @param containerAccessType The level of public access to the container. Defaults to 'private'.\n   * @param metadata Optional metadata for the container as key-value pairs.\n   * @returns The created Container instance.\n   * @throws Error if a container with the same name already exists within the storage account.\n   *\n   * This method creates a new container within the Azure storage account, allowing for the specification of access\n   * level and metadata. If the container already exists, it throws an error to prevent duplication.\n   *\n   * Example usage:\n   * ```typescript\n   * const container = storageAccount.addContainer('myContainer', 'private', { owner: 'IT' });\n   * ```\n   */\n\n  public addContainer(\n    name: string,\n    containerAccessType?: string,\n    metadata?: { [key: string]: string },\n  ): Container {\n    if (this.containers.has(name)) {\n      throw new Error(`Container '${name}' already exists.`);\n    }\n\n    const newContainer = new Container(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      containerAccessType: containerAccessType || \"private\",\n      metadata: metadata || {},\n    });\n\n    this.containers.set(name, newContainer);\n    return newContainer;\n  }\n\n  /**\n   * Adds a new file share to the storage account.\n   * @param name The name of the file share. Must be unique within the storage account.\n   * @param props Optional properties for configuring the file share, such as quota and access tier.\n   * @returns The created FileShare instance.\n   * @throws Error if a file share with the same name already exists.\n   *\n   * This method facilitates the addition of a file share to the storage account, with optional settings for\n   * capacity (quota) and data access frequency (access tier). If a file share with the same name exists, an error is thrown.\n   *\n   * Example usage:\n   * ```typescript\n   * const fileShare = storageAccount.addFileShare('myFileShare', { quota: 1024, accessTier: 'Hot' });\n   * ```\n   */\n\n  public addFileShare(name: string, props?: FileShareProps): FileShare {\n    if (this.shares.has(name)) {\n      throw new Error(`Share '${name}' already exists.`);\n    }\n\n    const defaults = {\n      quota: props?.quota || 1024,\n      accessTier: props?.accessTier || \"Hot\",\n      enabledProtocol: props?.enabledProtocol || \"SMB\",\n      acl: props?.acl || [],\n      metadata: props?.metadata || {},\n    };\n\n    const newShare = new FileShare(this, name, {\n      ...defaults,\n      name: name,\n      storageAccountName: this.name,\n    });\n\n    this.shares.set(name, newShare);\n    return newShare;\n  }\n\n  /**\n   * Adds a new table to the storage account.\n   * @param name The name of the table. Must be unique within the storage account.\n   * @param acl Optional access control list for the table, specifying permissions.\n   * @returns The created Table instance.\n   * @throws Error if a table with the same name already exists.\n   *\n   * This method creates a new table within the storage account, optionally allowing for access control configurations.\n   * It throws an error if a table with the same name already exists, ensuring uniqueness within the account.\n   *\n   * Example usage:\n   * ```typescript\n   * const table = storageAccount.addTable('myTable', [{ id: 'policy1', type: 'read' }]);\n   * ```\n   */\n\n  public addTable(name: string, acl?: StorageTableAcl[]): Table {\n    if (this.tables.has(name)) {\n      throw new Error(`Table '${name}' already exists.`);\n    }\n\n    const newTable = new Table(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      acl: acl,\n    });\n\n    this.tables.set(name, newTable);\n    return newTable;\n  }\n\n  /**\n   * Adds a new queue to the storage account.\n   * @param name The name of the queue. Must be unique within the storage account.\n   * @param metadata Optional metadata for the queue as key-value pairs.\n   * @returns The created Queue instance.\n   *\n   * This method creates a new queue in the storage account, with optional metadata. It is useful for message queuing\n   * in applications, enabling asynchronous task processing and inter-service communication.\n   *\n   * Example usage:\n   * ```typescript\n   * const queue = storageAccount.addQueue('myQueue', { priority: 'high' });\n   * ```\n   */\n\n  public addQueue(name: string, metadata?: { [key: string]: string }): Queue {\n    return new Queue(this, name, {\n      name: name,\n      storageAccountName: this.name,\n      metadata: metadata,\n    });\n  }\n\n  /**\n   * Adds network rules to the storage account to control access based on IP and virtual network settings.\n   * @param props Configuration properties for the network rules, including allowed IPs and virtual network subnet IDs.\n   * @returns The configured network rules.\n   *\n   * This method configures network rules for the storage account, specifying which IPs and virtual networks can access\n   * the storage resources. It allows detailed control over data security and access management.\n   *\n   * Example usage:\n   * ```typescript\n   * storageAccount.addNetworkRules({\n   *   bypass: ['AzureServices'],\n   *   defaultAction: 'Deny',\n   *   ipRules: ['1.2.3.4/32'],\n   *   virtualNetworkSubnetIds: ['subnetId'],\n   * });\n   * ```\n   */\n\n  public addNetworkRules(\n    props: NetworkRulesProps,\n  ): StorageAccountNetworkRulesA {\n    return new StorageAccountNetworkRulesA(this, \"rules\", {\n      storageAccountId: this.id,\n      bypass: props.bypass,\n      defaultAction: props.defaultAction,\n      ipRules: props.ipRules,\n      virtualNetworkSubnetIds: props.virtualNetworkSubnetIds,\n      privateLinkAccess: props.privateLinkAccess,\n    });\n  }\n}\n"]}

package/lib/azure-storageaccount/lib/container.d.ts

@@ -6,19 +6,62 @@ export declare class Container extends Construct {
     private readonly blobs;
     private readonly storageAccountName;
     private readonly storageContainerName;
+    /**
+     * Represents an Azure Storage Container within a specific Azure Storage Account.
+     *
+     * This class is designed for the creation and management of an Azure Storage Container, which serves as a unit of storage
+     * that houses data objects, known as blobs. Containers are analogous to directories in a file system, and are used to organize
+     * sets of blobs within a storage account. This class allows for granular control over blob storage, providing functionalities
+     * such as setting access levels, managing metadata, and implementing security measures like encryption scopes.
+     *
+     * @param scope - The scope in which to define this construct, typically a reference to the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the container.
+     * @param props - Configuration properties for the Azure Storage Container, based on the StorageContainerConfig interface. These include:
+     *                - `name`: The name of the storage container, which must be unique within the associated storage account.
+     *                - `storageAccountName`: The name of the storage account where this container is located.
+     *                - `containerAccessType`: Defines the level of public access to the container. Options include 'container',
+     *                  'blob', or 'none', controlling how the blobs within the container can be accessed.
+     *                - `defaultEncryptionScope`: Specifies the default encryption scope for the container, enhancing data security.
+     *                - `encryptionScopeOverrideEnabled`: Allows or prevents overriding the encryption scope on a per-blob basis.
+     *                - `metadata`: Key-value pairs that provide additional information about the container, which can be used for
+     *                  organizational, search, or billing purposes.
+     *                - `timeouts`: Specifies custom timeout settings for CRUD operations on the container, providing control over
+     *                  operation durations and retries.
+     *
+     * Example usage:
+     * ```typescript
+     * const storageContainer = new Container(this, 'MyContainer', {
+     *   name: 'mycontainer',
+     *   storageAccountName: 'mystorageaccount',
+     *   containerAccessType: 'blob',
+     *   defaultEncryptionScope: 'myEncryptionScope',
+     *   encryptionScopeOverrideEnabled: true,
+     *   metadata: {
+     *     department: 'Finance'
+     *   }
+     * });
+     * ```
+     * This instantiation sets up a storage container with specified properties including access types and metadata. It is ready
+     * to house blobs and provides methods to manage these blobs effectively.
+     */
     constructor(scope: Construct, id: string, props: StorageContainerConfig);
     /**
-     * Adds a blob to an Azure Storage Container.
+     * Adds a blob to this Azure Storage Container.
      *
-     * @param blobName The name of the blob to be added.
-     * @param filePath The file path or URL for the source of the blob's content.
-     * @param props Optional configuration properties for the blob, such as blob type, content type, and metadata.
-     * @returns The created AzureStorageBlob instance.
+     * This method facilitates the addition of a blob to an Azure Storage Container managed by this class. It handles the creation and
+     * configuration of the blob, including setting its type, source content, and metadata. This is useful for uploading various types
+     * of unstructured data, such as images, videos, documents, or other binary files, into a cloud-based storage solution.
      *
-     * This method enables the addition of a blob to an Azure Storage Container. It allows specifying
-     * the source of the blob's content, as well as other properties like the blob's type (default is 'Block'),
-     * content type, and metadata. The `filePath` parameter should point to the location of the file to be
-     * uploaded as a blob.
+     * @param blobName - The name of the blob to be added, which will be used as the blob's unique identifier within the container.
+     * @param filePath - The file path or URL for the source of the blob's content. This specifies the location of the file to be uploaded.
+     * @param props - Optional configuration properties for the blob, which include:
+     *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page'). Default is 'Block'.
+     *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data. This helps browsers
+     *                  and other clients handle the file correctly when it's downloaded or accessed.
+     *                - `metadata`: A dictionary of key-value pairs to store as metadata with the blob. Metadata is typically used to store additional
+     *                  details about the blob, such as tags, descriptions, or other attributes.
+     *
+     * @returns The newly created Blob object, which represents the blob added to the storage container.
      *
      * Example usage:
      * ```typescript
@@ -28,13 +71,52 @@ export declare class Container extends Construct {
      *   metadata: { customKey: 'customValue' }
      * });
      * ```
-     *
-     * In this example, a blob named 'exampleBlob' is added to the storage container. The content of the blob
-     * is sourced from a local file. The blob is of type 'Block' with a content type of 'text/plain' and custom metadata.
+     * In this example, a new blob named 'exampleBlob' is added to the storage container. The content of the blob is sourced
+     * from a local file specified by `filePath`. The blob is configured as a 'Block' type with 'text/plain' content type and
+     * custom metadata. The method returns the blob instance for further use or reference.
      */
     addBlob(blobName: string, filePath: string, props?: StorageBlobConfig): Blob;
 }
 export declare class Blob extends Construct {
     readonly name: string;
+    /**
+     * Represents a blob within an Azure Storage Container.
+     *
+     * This class is responsible for the creation and management of a blob in an Azure Storage Container. Blobs are unstructured
+     * data objects, which can include files like images, documents, videos, or any other file type. The Blob class provides a way
+     * to manage these files in the cloud, allowing for scalable, durable, and accessible data storage. This class supports various
+     * blob types such as block blobs for text and binary data, append blobs for log files, and page blobs for large volumes of
+     * random access data.
+     *
+     * @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 blob.
+     * @param props - Configuration properties for the Azure Storage Blob. These properties may include:
+     *                - `name`: The name of the blob, which must be unique within the container.
+     *                - `storageAccountName`: The name of the storage account in which the blob is stored.
+     *                - `storageContainerName`: The name of the storage container in which the blob resides.
+     *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page').
+     *                - `source`: The source of the blob's content, which could be a path to a file or a URL.
+     *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data.
+     *                - `metadata`: A dictionary of strings that represents metadata to associate with the blob.
+     *                - `accessTier`: The data access tier, affecting storage costs and data retrieval speeds.
+     *                - `cacheControl`, `contentEncoding`, `contentDisposition`, `contentMd5`: Optional parameters for controlling the caching behavior,
+     *                  encoding, content disposition, and integrity check of the blob.
+     *
+     * Example usage:
+     * ```typescript
+     * const myBlob = new Blob(this, 'MyBlob', {
+     *   name: 'exampleblob',
+     *   storageAccountName: 'mystorageaccount',
+     *   storageContainerName: 'mycontainer',
+     *   type: 'Block',
+     *   source: './path/to/file.jpg',
+     *   contentType: 'image/jpeg',
+     *   metadata: {
+     *     author: 'John Doe'
+     *   }
+     * });
+     * ```
+     * This class initializes a blob with the specified configurations and handles the uploading of content from the specified source.
+     */
     constructor(scope: Construct, id: string, props: StorageBlobConfig);
 }

package/lib/azure-storageaccount/lib/container.js

@@ -7,6 +7,44 @@ const storage_blob_1 = require("@cdktf/provider-azurerm/lib/storage-blob");
 const storage_container_1 = require("@cdktf/provider-azurerm/lib/storage-container");
 const constructs_1 = require("constructs");
 class Container extends constructs_1.Construct {
+    /**
+     * Represents an Azure Storage Container within a specific Azure Storage Account.
+     *
+     * This class is designed for the creation and management of an Azure Storage Container, which serves as a unit of storage
+     * that houses data objects, known as blobs. Containers are analogous to directories in a file system, and are used to organize
+     * sets of blobs within a storage account. This class allows for granular control over blob storage, providing functionalities
+     * such as setting access levels, managing metadata, and implementing security measures like encryption scopes.
+     *
+     * @param scope - The scope in which to define this construct, typically a reference to the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the container.
+     * @param props - Configuration properties for the Azure Storage Container, based on the StorageContainerConfig interface. These include:
+     *                - `name`: The name of the storage container, which must be unique within the associated storage account.
+     *                - `storageAccountName`: The name of the storage account where this container is located.
+     *                - `containerAccessType`: Defines the level of public access to the container. Options include 'container',
+     *                  'blob', or 'none', controlling how the blobs within the container can be accessed.
+     *                - `defaultEncryptionScope`: Specifies the default encryption scope for the container, enhancing data security.
+     *                - `encryptionScopeOverrideEnabled`: Allows or prevents overriding the encryption scope on a per-blob basis.
+     *                - `metadata`: Key-value pairs that provide additional information about the container, which can be used for
+     *                  organizational, search, or billing purposes.
+     *                - `timeouts`: Specifies custom timeout settings for CRUD operations on the container, providing control over
+     *                  operation durations and retries.
+     *
+     * Example usage:
+     * ```typescript
+     * const storageContainer = new Container(this, 'MyContainer', {
+     *   name: 'mycontainer',
+     *   storageAccountName: 'mystorageaccount',
+     *   containerAccessType: 'blob',
+     *   defaultEncryptionScope: 'myEncryptionScope',
+     *   encryptionScopeOverrideEnabled: true,
+     *   metadata: {
+     *     department: 'Finance'
+     *   }
+     * });
+     * ```
+     * This instantiation sets up a storage container with specified properties including access types and metadata. It is ready
+     * to house blobs and provides methods to manage these blobs effectively.
+     */
     constructor(scope, id, props) {
         super(scope, id);
         this.blobs = new Map();
@@ -22,17 +60,22 @@ class Container extends constructs_1.Construct {
         this.storageContainerName = container.name;
     }
     /**
-     * Adds a blob to an Azure Storage Container.
+     * Adds a blob to this Azure Storage Container.
      *
-     * @param blobName The name of the blob to be added.
-     * @param filePath The file path or URL for the source of the blob's content.
-     * @param props Optional configuration properties for the blob, such as blob type, content type, and metadata.
-     * @returns The created AzureStorageBlob instance.
+     * This method facilitates the addition of a blob to an Azure Storage Container managed by this class. It handles the creation and
+     * configuration of the blob, including setting its type, source content, and metadata. This is useful for uploading various types
+     * of unstructured data, such as images, videos, documents, or other binary files, into a cloud-based storage solution.
      *
-     * This method enables the addition of a blob to an Azure Storage Container. It allows specifying
-     * the source of the blob's content, as well as other properties like the blob's type (default is 'Block'),
-     * content type, and metadata. The `filePath` parameter should point to the location of the file to be
-     * uploaded as a blob.
+     * @param blobName - The name of the blob to be added, which will be used as the blob's unique identifier within the container.
+     * @param filePath - The file path or URL for the source of the blob's content. This specifies the location of the file to be uploaded.
+     * @param props - Optional configuration properties for the blob, which include:
+     *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page'). Default is 'Block'.
+     *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data. This helps browsers
+     *                  and other clients handle the file correctly when it's downloaded or accessed.
+     *                - `metadata`: A dictionary of key-value pairs to store as metadata with the blob. Metadata is typically used to store additional
+     *                  details about the blob, such as tags, descriptions, or other attributes.
+     *
+     * @returns The newly created Blob object, which represents the blob added to the storage container.
      *
      * Example usage:
      * ```typescript
@@ -42,9 +85,9 @@ class Container extends constructs_1.Construct {
      *   metadata: { customKey: 'customValue' }
      * });
      * ```
-     *
-     * In this example, a blob named 'exampleBlob' is added to the storage container. The content of the blob
-     * is sourced from a local file. The blob is of type 'Block' with a content type of 'text/plain' and custom metadata.
+     * In this example, a new blob named 'exampleBlob' is added to the storage container. The content of the blob is sourced
+     * from a local file specified by `filePath`. The blob is configured as a 'Block' type with 'text/plain' content type and
+     * custom metadata. The method returns the blob instance for further use or reference.
      */
     addBlob(blobName, filePath, props) {
         const newStorageBlob = new Blob(this, blobName, {
@@ -62,8 +105,47 @@ class Container extends constructs_1.Construct {
 }
 exports.Container = Container;
 _a = JSII_RTTI_SYMBOL_1;
-Container[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Container", version: "0.0.3-pre.6" };
+Container[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Container", version: "0.0.3-pre.7" };
 class Blob extends constructs_1.Construct {
+    /**
+     * Represents a blob within an Azure Storage Container.
+     *
+     * This class is responsible for the creation and management of a blob in an Azure Storage Container. Blobs are unstructured
+     * data objects, which can include files like images, documents, videos, or any other file type. The Blob class provides a way
+     * to manage these files in the cloud, allowing for scalable, durable, and accessible data storage. This class supports various
+     * blob types such as block blobs for text and binary data, append blobs for log files, and page blobs for large volumes of
+     * random access data.
+     *
+     * @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 blob.
+     * @param props - Configuration properties for the Azure Storage Blob. These properties may include:
+     *                - `name`: The name of the blob, which must be unique within the container.
+     *                - `storageAccountName`: The name of the storage account in which the blob is stored.
+     *                - `storageContainerName`: The name of the storage container in which the blob resides.
+     *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page').
+     *                - `source`: The source of the blob's content, which could be a path to a file or a URL.
+     *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data.
+     *                - `metadata`: A dictionary of strings that represents metadata to associate with the blob.
+     *                - `accessTier`: The data access tier, affecting storage costs and data retrieval speeds.
+     *                - `cacheControl`, `contentEncoding`, `contentDisposition`, `contentMd5`: Optional parameters for controlling the caching behavior,
+     *                  encoding, content disposition, and integrity check of the blob.
+     *
+     * Example usage:
+     * ```typescript
+     * const myBlob = new Blob(this, 'MyBlob', {
+     *   name: 'exampleblob',
+     *   storageAccountName: 'mystorageaccount',
+     *   storageContainerName: 'mycontainer',
+     *   type: 'Block',
+     *   source: './path/to/file.jpg',
+     *   contentType: 'image/jpeg',
+     *   metadata: {
+     *     author: 'John Doe'
+     *   }
+     * });
+     * ```
+     * This class initializes a blob with the specified configurations and handles the uploading of content from the specified source.
+     */
     constructor(scope, id, props) {
         super(scope, id);
         // Create a storage container
@@ -81,5 +163,5 @@ class Blob extends constructs_1.Construct {
 }
 exports.Blob = Blob;
 _b = JSII_RTTI_SYMBOL_1;
-Blob[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Blob", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,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
+Blob[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Blob", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.js","sourceRoot":"","sources":["../../../src/azure-storageaccount/lib/container.ts"],"names":[],"mappings":";;;;;AAAA,2EAGkD;AAClD,qFAGuD;AACvD,2CAAuC;AAEvC,MAAa,SAAU,SAAQ,sBAAS;IAMtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA6B;QACrE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAgB,CAAC;QAErC,6BAA6B;QAC7B,MAAM,SAAS,GAAG,IAAI,oCAAgB,CAAC,IAAI,EAAE,WAAW,EAAE;YACxD,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;QACnD,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC,IAAI,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,OAAO,CAAC,QAAgB,EAAE,QAAgB,EAAE,KAAyB;QACnE,MAAM,cAAc,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE;YAC9C,IAAI,EAAE,QAAQ;YACd,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,IAAI,EAAE,KAAK,EAAE,IAAI,IAAI,OAAO;YAC5B,MAAM,EAAE,QAAQ;YAChB,WAAW,EAAE,KAAK,EAAE,WAAW,IAAI,0BAA0B;YAC7D,QAAQ,EAAE,KAAK,EAAE,QAAQ,IAAI,EAAE;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;QACzC,OAAO,cAAc,CAAC;IACxB,CAAC;;AAxGH,8BAyGC;;;AAED,MAAa,IAAK,SAAQ,sBAAS;IAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAwB;QAChE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,6BAA6B;QAC7B,IAAI,0BAAW,CAAC,IAAI,EAAE,MAAM,EAAE;YAC5B,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,oBAAoB,EAAE,KAAK,CAAC,oBAAoB;YAChD,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ;SACzB,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;;AAzDH,oBA0DC","sourcesContent":["import {\n  StorageBlob,\n  StorageBlobConfig,\n} from \"@cdktf/provider-azurerm/lib/storage-blob\";\nimport {\n  StorageContainer,\n  StorageContainerConfig,\n} from \"@cdktf/provider-azurerm/lib/storage-container\";\nimport { Construct } from \"constructs\";\n\nexport class Container extends Construct {\n  public readonly name: string;\n  private readonly blobs: Map<string, Blob>;\n  private readonly storageAccountName: string;\n  private readonly storageContainerName: string;\n\n  /**\n   * Represents an Azure Storage Container within a specific Azure Storage Account.\n   *\n   * This class is designed for the creation and management of an Azure Storage Container, which serves as a unit of storage\n   * that houses data objects, known as blobs. Containers are analogous to directories in a file system, and are used to organize\n   * sets of blobs within a storage account. This class allows for granular control over blob storage, providing functionalities\n   * such as setting access levels, managing metadata, and implementing security measures like encryption scopes.\n   *\n   * @param scope - The scope in which to define this construct, typically a reference to the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the container.\n   * @param props - Configuration properties for the Azure Storage Container, based on the StorageContainerConfig interface. These include:\n   *                - `name`: The name of the storage container, which must be unique within the associated storage account.\n   *                - `storageAccountName`: The name of the storage account where this container is located.\n   *                - `containerAccessType`: Defines the level of public access to the container. Options include 'container',\n   *                  'blob', or 'none', controlling how the blobs within the container can be accessed.\n   *                - `defaultEncryptionScope`: Specifies the default encryption scope for the container, enhancing data security.\n   *                - `encryptionScopeOverrideEnabled`: Allows or prevents overriding the encryption scope on a per-blob basis.\n   *                - `metadata`: Key-value pairs that provide additional information about the container, which can be used for\n   *                  organizational, search, or billing purposes.\n   *                - `timeouts`: Specifies custom timeout settings for CRUD operations on the container, providing control over\n   *                  operation durations and retries.\n   *\n   * Example usage:\n   * ```typescript\n   * const storageContainer = new Container(this, 'MyContainer', {\n   *   name: 'mycontainer',\n   *   storageAccountName: 'mystorageaccount',\n   *   containerAccessType: 'blob',\n   *   defaultEncryptionScope: 'myEncryptionScope',\n   *   encryptionScopeOverrideEnabled: true,\n   *   metadata: {\n   *     department: 'Finance'\n   *   }\n   * });\n   * ```\n   * This instantiation sets up a storage container with specified properties including access types and metadata. It is ready\n   * to house blobs and provides methods to manage these blobs effectively.\n   */\n  constructor(scope: Construct, id: string, props: StorageContainerConfig) {\n    super(scope, id);\n\n    this.blobs = new Map<string, Blob>();\n\n    // Create a storage container\n    const container = new StorageContainer(this, \"container\", {\n      name: props.name,\n      storageAccountName: props.storageAccountName,\n      containerAccessType: props.containerAccessType,\n      metadata: props.metadata,\n    });\n\n    this.name = props.name;\n    this.storageAccountName = props.storageAccountName;\n    this.storageContainerName = container.name;\n  }\n\n  /**\n   * Adds a blob to this Azure Storage Container.\n   *\n   * This method facilitates the addition of a blob to an Azure Storage Container managed by this class. It handles the creation and\n   * configuration of the blob, including setting its type, source content, and metadata. This is useful for uploading various types\n   * of unstructured data, such as images, videos, documents, or other binary files, into a cloud-based storage solution.\n   *\n   * @param blobName - The name of the blob to be added, which will be used as the blob's unique identifier within the container.\n   * @param filePath - The file path or URL for the source of the blob's content. This specifies the location of the file to be uploaded.\n   * @param props - Optional configuration properties for the blob, which include:\n   *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page'). Default is 'Block'.\n   *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data. This helps browsers\n   *                  and other clients handle the file correctly when it's downloaded or accessed.\n   *                - `metadata`: A dictionary of key-value pairs to store as metadata with the blob. Metadata is typically used to store additional\n   *                  details about the blob, such as tags, descriptions, or other attributes.\n   *\n   * @returns The newly created Blob object, which represents the blob added to the storage container.\n   *\n   * Example usage:\n   * ```typescript\n   * const storageBlob = storageContainer.addBlob('exampleBlob', './path/to/local/file.txt', {\n   *   type: 'Block',\n   *   contentType: 'text/plain',\n   *   metadata: { customKey: 'customValue' }\n   * });\n   * ```\n   * In this example, a new blob named 'exampleBlob' is added to the storage container. The content of the blob is sourced\n   * from a local file specified by `filePath`. The blob is configured as a 'Block' type with 'text/plain' content type and\n   * custom metadata. The method returns the blob instance for further use or reference.\n   */\n  addBlob(blobName: string, filePath: string, props?: StorageBlobConfig): Blob {\n    const newStorageBlob = new Blob(this, blobName, {\n      name: blobName,\n      storageAccountName: this.storageAccountName,\n      storageContainerName: this.storageContainerName,\n      type: props?.type || \"Block\",\n      source: filePath,\n      contentType: props?.contentType || \"application/octet-stream\",\n      metadata: props?.metadata || {},\n    });\n    this.blobs.set(blobName, newStorageBlob);\n    return newStorageBlob;\n  }\n}\n\nexport class Blob extends Construct {\n  readonly name: string;\n\n  /**\n   * Represents a blob within an Azure Storage Container.\n   *\n   * This class is responsible for the creation and management of a blob in an Azure Storage Container. Blobs are unstructured\n   * data objects, which can include files like images, documents, videos, or any other file type. The Blob class provides a way\n   * to manage these files in the cloud, allowing for scalable, durable, and accessible data storage. This class supports various\n   * blob types such as block blobs for text and binary data, append blobs for log files, and page blobs for large volumes of\n   * random access data.\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 blob.\n   * @param props - Configuration properties for the Azure Storage Blob. These properties may include:\n   *                - `name`: The name of the blob, which must be unique within the container.\n   *                - `storageAccountName`: The name of the storage account in which the blob is stored.\n   *                - `storageContainerName`: The name of the storage container in which the blob resides.\n   *                - `type`: The type of the blob (e.g., 'Block', 'Append', 'Page').\n   *                - `source`: The source of the blob's content, which could be a path to a file or a URL.\n   *                - `contentType`: The MIME type of the blob's content, such as 'application/octet-stream' for binary data.\n   *                - `metadata`: A dictionary of strings that represents metadata to associate with the blob.\n   *                - `accessTier`: The data access tier, affecting storage costs and data retrieval speeds.\n   *                - `cacheControl`, `contentEncoding`, `contentDisposition`, `contentMd5`: Optional parameters for controlling the caching behavior,\n   *                  encoding, content disposition, and integrity check of the blob.\n   *\n   * Example usage:\n   * ```typescript\n   * const myBlob = new Blob(this, 'MyBlob', {\n   *   name: 'exampleblob',\n   *   storageAccountName: 'mystorageaccount',\n   *   storageContainerName: 'mycontainer',\n   *   type: 'Block',\n   *   source: './path/to/file.jpg',\n   *   contentType: 'image/jpeg',\n   *   metadata: {\n   *     author: 'John Doe'\n   *   }\n   * });\n   * ```\n   * This class initializes a blob with the specified configurations and handles the uploading of content from the specified source.\n   */\n  constructor(scope: Construct, id: string, props: StorageBlobConfig) {\n    super(scope, id);\n\n    // Create a storage container\n    new StorageBlob(this, \"blob\", {\n      name: props.name,\n      storageAccountName: props.storageAccountName,\n      storageContainerName: props.storageContainerName,\n      type: props.type,\n      source: props.source,\n      contentType: props.contentType,\n      metadata: props.metadata,\n    });\n\n    this.name = props.name;\n  }\n}\n"]}