@microsoft/terraform-cdk-constructs 0.0.3-pre.10

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

@@ -0,0 +1,225 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const storage_account_1 = require("@cdktf/provider-azurerm/lib/storage-account");
+const storage_account_network_rules_1 = require("@cdktf/provider-azurerm/lib/storage-account-network-rules");
+const container_1 = require("./container");
+const fileshare_1 = require("./fileshare");
+const queue_1 = require("./queue");
+const table_1 = require("./table");
+const lib_1 = require("../../core-azure/lib");
+class Account extends lib_1.AzureResourceWithAlert {
+    /**
+     * 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);
+        this.props = props;
+        this.resourceGroup = this.setupResourceGroup(props);
+        this.containers = new Map();
+        this.shares = new Map();
+        this.tables = new Map();
+        this.name = props.name;
+        this.location = props.location;
+        // default Storage Account Settings
+        const defaults = {
+            accountReplicationType: "LRS",
+            accountTier: "Standard",
+            enableHttpsTrafficOnly: true,
+            accessTier: "Hot",
+            isHnsEnabled: true,
+            minTlsVersion: "TLS1_2",
+            publicnetworkAccessEnabled: false,
+            ...props,
+        };
+        // Create the storage account
+        const storageAccount = new storage_account_1.StorageAccount(this, "storageaccount", {
+            ...defaults,
+            name: props.name,
+            resourceGroupName: this.resourceGroup.name,
+            location: props.location,
+            tags: props.tags,
+        });
+        this.id = storageAccount.id;
+        this.name = storageAccount.name;
+        this.accountKind = storageAccount.accountKind;
+        this.accountTier = storageAccount.accountTier;
+    }
+    /**
+     * Adds a new container to the storage account.
+     * @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', { owner: 'IT' });
+     * ```
+     */
+    addContainer(name, containerAccessType, metadata) {
+        if (this.containers.has(name)) {
+            throw new Error(`Container '${name}' already exists.`);
+        }
+        const newContainer = new container_1.Container(this, name, {
+            name: name,
+            storageAccountName: this.name,
+            containerAccessType: containerAccessType || "private",
+            metadata: metadata || {},
+        });
+        this.containers.set(name, newContainer);
+        return newContainer;
+    }
+    /**
+     * Adds a new file share to the storage account.
+     * @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.addFileShare('myFileShare', { quota: 1024, accessTier: 'Hot' });
+     * ```
+     */
+    addFileShare(name, props) {
+        if (this.shares.has(name)) {
+            throw new Error(`Share '${name}' already exists.`);
+        }
+        const defaults = {
+            quota: props?.quota || 1024,
+            accessTier: props?.accessTier || "Hot",
+            enabledProtocol: props?.enabledProtocol || "SMB",
+            acl: props?.acl || [],
+            metadata: props?.metadata || {},
+        };
+        const newShare = new fileshare_1.FileShare(this, name, {
+            ...defaults,
+            name: name,
+            storageAccountName: this.name,
+        });
+        this.shares.set(name, newShare);
+        return newShare;
+    }
+    /**
+     * Adds a new table to the storage account.
+     * @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', [{ id: 'policy1', type: 'read' }]);
+     * ```
+     */
+    addTable(name, acl) {
+        if (this.tables.has(name)) {
+            throw new Error(`Table '${name}' already exists.`);
+        }
+        const newTable = new table_1.Table(this, name, {
+            name: name,
+            storageAccountName: this.name,
+            acl: acl,
+        });
+        this.tables.set(name, newTable);
+        return newTable;
+    }
+    /**
+     * Adds a new queue to the storage account.
+     * @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', { priority: 'high' });
+     * ```
+     */
+    addQueue(name, metadata) {
+        return new queue_1.Queue(this, name, {
+            name: name,
+            storageAccountName: this.name,
+            metadata: metadata,
+        });
+    }
+    /**
+     * 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'],
+     * });
+     * ```
+     */
+    addNetworkRules(props) {
+        return new storage_account_network_rules_1.StorageAccountNetworkRulesA(this, "rules", {
+            storageAccountId: this.id,
+            bypass: props.bypass,
+            defaultAction: props.defaultAction,
+            ipRules: props.ipRules,
+            virtualNetworkSubnetIds: props.virtualNetworkSubnetIds,
+            privateLinkAccess: props.privateLinkAccess,
+        });
+    }
+}
+exports.Account = Account;
+_a = JSII_RTTI_SYMBOL_1;
+Account[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Account", version: "0.0.3-pre.10" };
+//# 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

@@ -0,0 +1,122 @@
+import { StorageBlobConfig } from "@cdktf/provider-azurerm/lib/storage-blob";
+import { StorageContainerConfig } from "@cdktf/provider-azurerm/lib/storage-container";
+import { Construct } from "constructs";
+export declare class Container extends Construct {
+    readonly name: string;
+    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 this Azure Storage Container.
+     *
+     * 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.
+     *
+     * @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
+     * const storageBlob = storageContainer.addBlob('exampleBlob', './path/to/local/file.txt', {
+     *   type: 'Block',
+     *   contentType: 'text/plain',
+     *   metadata: { customKey: 'customValue' }
+     * });
+     * ```
+     * 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

@@ -0,0 +1,167 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blob = exports.Container = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+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();
+        // Create a storage container
+        const container = new storage_container_1.StorageContainer(this, "container", {
+            name: props.name,
+            storageAccountName: props.storageAccountName,
+            containerAccessType: props.containerAccessType,
+            metadata: props.metadata,
+        });
+        this.name = props.name;
+        this.storageAccountName = props.storageAccountName;
+        this.storageContainerName = container.name;
+    }
+    /**
+     * Adds a blob to this Azure Storage Container.
+     *
+     * 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.
+     *
+     * @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
+     * const storageBlob = storageContainer.addBlob('exampleBlob', './path/to/local/file.txt', {
+     *   type: 'Block',
+     *   contentType: 'text/plain',
+     *   metadata: { customKey: 'customValue' }
+     * });
+     * ```
+     * 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, {
+            name: blobName,
+            storageAccountName: this.storageAccountName,
+            storageContainerName: this.storageContainerName,
+            type: props?.type || "Block",
+            source: filePath,
+            contentType: props?.contentType || "application/octet-stream",
+            metadata: props?.metadata || {},
+        });
+        this.blobs.set(blobName, newStorageBlob);
+        return newStorageBlob;
+    }
+}
+exports.Container = Container;
+_a = JSII_RTTI_SYMBOL_1;
+Container[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Container", version: "0.0.3-pre.10" };
+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
+        new storage_blob_1.StorageBlob(this, "blob", {
+            name: props.name,
+            storageAccountName: props.storageAccountName,
+            storageContainerName: props.storageContainerName,
+            type: props.type,
+            source: props.source,
+            contentType: props.contentType,
+            metadata: props.metadata,
+        });
+        this.name = props.name;
+    }
+}
+exports.Blob = Blob;
+_b = JSII_RTTI_SYMBOL_1;
+Blob[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_storageaccount.Blob", version: "0.0.3-pre.10" };
+//# 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"]}