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

package/lib/azure-storageaccount/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtc3RvcmFnZWFjY291bnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

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

@@ -0,0 +1,205 @@
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { StorageAccountNetworkRulesA, StorageAccountNetworkRulesPrivateLinkAccessA } from "@cdktf/provider-azurerm/lib/storage-account-network-rules";
+import { StorageTableAcl } from "@cdktf/provider-azurerm/lib/storage-table";
+import { Construct } from "constructs";
+import { Container } from "./container";
+import { FileShare, FileShareProps } from "./fileshare";
+import { Queue } from "./queue";
+import { Table } from "./table";
+import { AzureResourceWithAlert } from "../../core-azure/lib";
+export interface NetworkRulesProps {
+    /**
+     * Specifies which traffic to bypass from the network rules. The possible values are 'AzureServices', 'Logging', 'Metrics',
+     * and 'None'. Bypassing 'AzureServices' enables Azure's internal services to access the storage account.
+     */
+    readonly bypass?: string[];
+    /**
+     * The default action of the network rule set. Options are 'Allow' or 'Deny'. Set to 'Deny' to enable network rules and restrict
+     * access to the storage account. 'Allow' permits access by default.
+     */
+    readonly defaultAction: string;
+    /**
+     * An array of IP rules to allow access to the storage account. These are specified as CIDR ranges.
+     * Example: ['1.2.3.4/32', '5.6.7.0/24'] to allow specific IPs/subnets.
+     */
+    readonly ipRules?: string[];
+    /**
+     * An array of virtual network subnet IDs that are allowed to access the storage account. This enables you to secure the storage
+     * account to a specific virtual network and subnet within Azure.
+     */
+    readonly virtualNetworkSubnetIds?: string[];
+    /**
+     * An array of objects representing the private link access settings. Each object in the array defines the sub-resource name
+     * (e.g., 'blob', 'file') and its respective private endpoint connections for the storage account.
+     */
+    readonly privateLinkAccess?: StorageAccountNetworkRulesPrivateLinkAccessA[];
+}
+export interface AccountProps {
+    /**
+     * The type of replication to use for the storage account. This determines how your data is replicated across Azure's infrastructure.
+     * Example values: LRS (Locally Redundant Storage), GRS (Geo-Redundant Storage), RAGRS (Read Access Geo-Redundant Storage).
+     */
+    readonly accountReplicationType?: string;
+    /**
+     * The performance tier of the storage account. Determines the type of hardware and performance level.
+     * Example values: Standard, Premium.
+     */
+    readonly accountTier?: string;
+    /**
+     * The Azure region in which to create the storage account.
+     */
+    readonly location: string;
+    /**
+     * The name of the storage account. Must be unique across Azure.
+     */
+    readonly name: string;
+    /**
+     * The name of the Azure resource group in which to create the storage account.
+     */
+    readonly resourceGroup?: ResourceGroup;
+    /**
+     * Tags to apply to the storage account, used for categorization and billing purposes.
+     * Format: { [key: string]: string }
+     */
+    readonly tags?: {
+        readonly [key: string]: string;
+    };
+    /**
+     * A boolean flag indicating whether to enforce HTTPS for data transfer to the storage account.
+     */
+    readonly enableHttpsTrafficOnly?: boolean;
+    /**
+     * Managed Service Identity (MSI) details. Used for enabling and managing Azure Active Directory (AAD) authentication.
+     */
+    readonly identity?: any;
+    /**
+     * The data access tier of the storage account, which impacts storage costs and data retrieval speeds.
+     * Example values: Hot, Cool.
+     */
+    readonly accessTier?: string;
+    /**
+     * A flag indicating whether the Hierarchical Namespace (HNS) is enabled, which is required for Azure Data Lake Storage Gen2 features.
+     */
+    readonly isHnsEnabled?: boolean;
+    /**
+     * The minimum TLS version to be used for securing connections to the storage account.
+     * Example values: TLS1_0, TLS1_1, TLS1_2.
+     */
+    readonly minTlsVersion?: string;
+    /**
+     * A boolean flag indicating whether public network access to the storage account is allowed.
+     */
+    readonly publicNetworkAccessEnabled?: boolean;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/azurerm/3.92.0/docs/resources/storage_account#account_kind StorageAccount#account_kind}
+     */
+    readonly accountKind?: string;
+}
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare class Account extends AzureResourceWithAlert {
+    readonly props: AccountProps;
+    id: string;
+    readonly name: string;
+    readonly location: string;
+    resourceGroup: ResourceGroup;
+    readonly accountKind: string;
+    readonly accountTier: string;
+    private readonly containers;
+    private readonly shares;
+    private readonly tables;
+    /**
+     * 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.
+     */
+    constructor(scope: Construct, id: string, props: AccountProps);
+    /**
+     * 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.
+     *
+     * Example usage:
+     * ```typescript
+     * const container = storageAccount.addContainer('myContainer', 'private');
+     * ```
+     */
+    addContainer(name: string, containerAccessType?: string, metadata?: {
+        [key: string]: string;
+    }): Container;
+    /**
+     * 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.
+     *
+     * Example usage:
+     * ```typescript
+     * const fileShare = storageAccount.addShare('myFileShare', { quota: 1024, accessTier: 'Hot' });
+     * ```
+     */
+    addFileShare(name: string, props?: FileShareProps): FileShare;
+    /**
+     * 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.
+     * @throws Error if a table with the same name already exists.
+     *
+     * Example usage:
+     * ```typescript
+     * const table = storageAccount.addTable('myTable');
+     * ```
+     */
+    addTable(name: string, acl?: StorageTableAcl[]): Table;
+    /**
+     * 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.
+     *
+     * Example usage:
+     * ```typescript
+     * const queue = storageAccount.addQueue('myQueue');
+     * ```
+     */
+    addQueue(name: string, metadata?: {
+        [key: string]: string;
+    }): Queue;
+    /**
+     * Adds network rules to the storage account.
+     * @param props Configuration properties for the network rules.
+     * @returns The configured StorageAccountNetworkRulesA.
+     *
+     * Example usage:
+     * ```typescript
+     * storageAccount.addNetworkRules({
+     *     bypass: ['AzureServices'],
+     *     defaultAction: 'Deny',
+     *     ipRules: ['1.2.3.4/32'],
+     *     virtualNetworkSubnetIds: ['subnetId'],
+     *  });
+     * ```
+     */
+    addNetworkRules(props: NetworkRulesProps): StorageAccountNetworkRulesA;
+}

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

@@ -0,0 +1,198 @@
+"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");
+/**
+ * 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.
+     */
+    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.
+     * @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.
+     *
+     * Example usage:
+     * ```typescript
+     * const container = storageAccount.addContainer('myContainer', 'private');
+     * ```
+     */
+    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.
+     * @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.
+     *
+     * Example usage:
+     * ```typescript
+     * const fileShare = storageAccount.addShare('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.
+     * @param acl Optional access control list for the table.
+     * @returns The created AzureStorageTable.
+     * @throws Error if a table with the same name already exists.
+     *
+     * Example usage:
+     * ```typescript
+     * const table = storageAccount.addTable('myTable');
+     * ```
+     */
+    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.
+     * @param metadata Optional metadata for the queue.
+     * @returns The created AzureStorageQueue.
+     *
+     * Example usage:
+     * ```typescript
+     * const queue = storageAccount.addQueue('myQueue');
+     * ```
+     */
+    addQueue(name, metadata) {
+        return new queue_1.Queue(this, name, {
+            name: name,
+            storageAccountName: this.name,
+            metadata: metadata,
+        });
+    }
+    /**
+     * Adds network rules to the storage account.
+     * @param props Configuration properties for the network rules.
+     * @returns The configured StorageAccountNetworkRulesA.
+     *
+     * 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.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"]}

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

@@ -0,0 +1,40 @@
+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;
+    constructor(scope: Construct, id: string, props: StorageContainerConfig);
+    /**
+     * Adds a blob to an 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 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.
+     *
+     * 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 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.
+     */
+    addBlob(blobName: string, filePath: string, props?: StorageBlobConfig): Blob;
+}
+export declare class Blob extends Construct {
+    readonly name: string;
+    constructor(scope: Construct, id: string, props: StorageBlobConfig);
+}

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

@@ -0,0 +1,85 @@
+"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 {
+    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 an 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 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.
+     *
+     * 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 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.
+     */
+    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.6" };
+class Blob extends constructs_1.Construct {
+    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.6" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,69 @@
+import { StorageShareConfig } from "@cdktf/provider-azurerm/lib/storage-share";
+import { StorageShareFileConfig } from "@cdktf/provider-azurerm/lib/storage-share-file";
+import { Construct } from "constructs";
+export interface FileShareProps {
+    /**
+     * The maximum size of the storage share, in gigabytes.
+     */
+    readonly quota?: number;
+    /**
+     * The access tier of the storage share. This property is only applicable to storage shares with a premium account type.
+     * Example values: Hot, Cool.
+     */
+    readonly accessTier?: string;
+    /**
+     * The protocol to use when accessing the storage share.
+     * Example values: SMB, NFS.
+     */
+    readonly enabledProtocol?: string;
+    /**
+     * A list of access control rules for the storage share.
+     */
+    readonly acl?: any;
+    /**
+     * A mapping of tags to assign to the storage share.
+     * Format: { [key: string]: string }
+     */
+    readonly metadata?: {
+        readonly [key: string]: string;
+    };
+}
+export declare class FileShare extends Construct {
+    readonly name: string;
+    readonly id: string;
+    private readonly files;
+    readonly storageAccountName: string;
+    readonly storageShareName: string;
+    constructor(scope: Construct, id: string, props: StorageShareConfig);
+    /**
+     * Adds a file to the Azure Storage File Share.
+     *
+     * @param fileName The name of the file to be added.
+     * @param fileSource Optional path or URL to the source of the file's content.
+     * @param props Optional configuration properties for the file, such as content type, encoding, and metadata.
+     * @returns The created AzureStorageShareFile instance.
+     *
+     * This method allows you to add a file to your Azure Storage File Share, optionally specifying
+     * the file's content source and other properties like content type, encoding, and metadata.
+     * If `fileSource` is provided, the content of the file is sourced from this location.
+     * The `props` parameter allows for further customization of the file, such as setting the content type
+     * (default is 'application/octet-stream') and adding metadata.
+     *
+     * Example usage:
+     * ```typescript
+     * const storageShareFile = storageShare.addFile('example.txt', './path/to/local/file.txt', {
+     *   contentType: 'text/plain',
+     *   metadata: { customKey: 'customValue' }
+     * });
+     * ```
+     *
+     * In this example, a text file named 'example.txt' is added to the storage share. The content of the file
+     * is sourced from a local file, and the content type is specified as 'text/plain' with custom metadata.
+     */
+    addFile(fileName: string, fileSource?: string, props?: StorageShareFileConfig): File;
+}
+export declare class File extends Construct {
+    readonly name: string;
+    readonly id: string;
+    constructor(scope: Construct, id: string, props: StorageShareFileConfig);
+}