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

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

@@ -0,0 +1,311 @@
+/**
+ * Unified Azure Storage Account implementation using VersionedAzapiResource framework
+ *
+ * This class replaces all version-specific Storage Account implementations with a single
+ * unified class that automatically handles version management, schema validation, and
+ * property transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2023-01-01 (Active)
+ * - 2023-05-01 (Active)
+ * - 2024-01-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full backward compatibility with existing Storage Account interface
+ * - JSII compliance for multi-language support
+ */
+import * as cdktf from "cdktf";
+import { Construct } from "constructs";
+import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
+import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * SKU configuration for Storage Account
+ */
+export interface StorageAccountSku {
+    /**
+     * The SKU name (Standard_LRS, Standard_GRS, Standard_RAGRS, Standard_ZRS, Premium_LRS, Premium_ZRS)
+     */
+    readonly name: string;
+}
+/**
+ * IP rule for network ACLs
+ */
+export interface StorageAccountIpRule {
+    /**
+     * IP address or CIDR range
+     */
+    readonly value: string;
+}
+/**
+ * Virtual network rule for network ACLs
+ */
+export interface StorageAccountVirtualNetworkRule {
+    /**
+     * Virtual network resource ID
+     */
+    readonly id: string;
+}
+/**
+ * Network ACL configuration for Storage Account
+ */
+export interface StorageAccountNetworkAcls {
+    /**
+     * Default action when no rule matches (Allow or Deny)
+     */
+    readonly defaultAction?: string;
+    /**
+     * IP rules for the storage account
+     */
+    readonly ipRules?: StorageAccountIpRule[];
+    /**
+     * Virtual network rules for the storage account
+     */
+    readonly virtualNetworkRules?: StorageAccountVirtualNetworkRule[];
+    /**
+     * Whether to bypass network rules for Azure services
+     */
+    readonly bypass?: string;
+}
+/**
+ * Identity configuration for Storage Account
+ */
+export interface StorageAccountIdentity {
+    /**
+     * The type of identity (SystemAssigned, UserAssigned, SystemAssigned,UserAssigned)
+     */
+    readonly type: string;
+    /**
+     * User assigned identity IDs
+     */
+    readonly userAssignedIdentities?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Encryption service configuration
+ */
+export interface StorageAccountEncryptionService {
+    /**
+     * Whether encryption is enabled
+     */
+    readonly enabled?: boolean;
+}
+/**
+ * Encryption services configuration
+ */
+export interface StorageAccountEncryptionServices {
+    /**
+     * Blob service encryption
+     */
+    readonly blob?: StorageAccountEncryptionService;
+    /**
+     * File service encryption
+     */
+    readonly file?: StorageAccountEncryptionService;
+    /**
+     * Table service encryption
+     */
+    readonly table?: StorageAccountEncryptionService;
+    /**
+     * Queue service encryption
+     */
+    readonly queue?: StorageAccountEncryptionService;
+}
+/**
+ * Encryption configuration for Storage Account
+ */
+export interface StorageAccountEncryption {
+    /**
+     * Encryption services (blob, file, table, queue)
+     */
+    readonly services?: StorageAccountEncryptionServices;
+    /**
+     * Key source (Microsoft.Storage or Microsoft.Keyvault)
+     */
+    readonly keySource?: string;
+}
+/**
+ * Properties for the unified Azure Storage Account
+ *
+ * Extends VersionedAzapiResourceProps with Storage Account specific properties
+ */
+export interface StorageAccountProps extends AzapiResourceProps {
+    /**
+     * The SKU (pricing tier) for the Storage Account
+     * @example { name: "Standard_LRS" }
+     */
+    readonly sku: StorageAccountSku;
+    /**
+     * The kind of Storage Account
+     * @default "StorageV2"
+     * @example "StorageV2", "BlobStorage", "BlockBlobStorage", "FileStorage"
+     */
+    readonly kind?: string;
+    /**
+     * The access tier for blob storage
+     * @default "Hot"
+     * @example "Hot", "Cool"
+     */
+    readonly accessTier?: string;
+    /**
+     * Whether to allow only HTTPS traffic
+     * @default true
+     */
+    readonly enableHttpsTrafficOnly?: boolean;
+    /**
+     * The minimum TLS version required
+     * @default "TLS1_2"
+     */
+    readonly minimumTlsVersion?: string;
+    /**
+     * Whether to allow public access to blobs
+     * @default false
+     */
+    readonly allowBlobPublicAccess?: boolean;
+    /**
+     * Network ACL rules for the storage account
+     */
+    readonly networkAcls?: StorageAccountNetworkAcls;
+    /**
+     * Managed identity configuration
+     */
+    readonly identity?: StorageAccountIdentity;
+    /**
+     * Encryption settings
+     */
+    readonly encryption?: StorageAccountEncryption;
+    /**
+     * The lifecycle rules to ignore changes
+     * @example ["tags"]
+     */
+    readonly ignoreChanges?: string[];
+    /**
+     * Resource group ID where the storage account will be created
+     */
+    readonly resourceGroupId?: string;
+}
+/**
+ * Storage Account properties for the request body
+ */
+export interface StorageAccountBodyProperties {
+    readonly accessTier?: string;
+    readonly supportsHttpsTrafficOnly?: boolean;
+    readonly minimumTlsVersion?: string;
+    readonly allowBlobPublicAccess?: boolean;
+    readonly networkAcls?: StorageAccountNetworkAcls;
+    readonly encryption?: StorageAccountEncryption;
+}
+/**
+ * The resource body interface for Azure Storage Account API calls
+ */
+export interface StorageAccountBody {
+    readonly location: string;
+    readonly tags?: {
+        [key: string]: string;
+    };
+    readonly sku: StorageAccountSku;
+    readonly kind: string;
+    readonly properties?: StorageAccountBodyProperties;
+    readonly identity?: StorageAccountIdentity;
+}
+/**
+ * Unified Azure Storage Account implementation
+ *
+ * This class provides a single, version-aware implementation that replaces all
+ * version-specific Storage Account classes. It automatically handles version
+ * resolution, schema validation, and property transformation while maintaining
+ * full backward compatibility.
+ *
+ * @example
+ * // Basic usage with automatic version resolution:
+ * const storageAccount = new StorageAccount(this, "storage", {
+ *   name: "mystorageaccount",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "Standard_LRS" },
+ * });
+ *
+ * @example
+ * // Usage with explicit version pinning:
+ * const storageAccount = new StorageAccount(this, "storage", {
+ *   name: "mystorageaccount",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "Standard_LRS" },
+ *   apiVersion: "2023-05-01",
+ * });
+ *
+ * @stability stable
+ */
+export declare class StorageAccount extends AzapiResource {
+    private static schemasRegistered;
+    /**
+     * Ensures that Storage Account schemas are registered with the ApiVersionManager
+     */
+    private static ensureSchemasRegistered;
+    readonly props: StorageAccountProps;
+    readonly idOutput: cdktf.TerraformOutput;
+    readonly locationOutput: cdktf.TerraformOutput;
+    readonly nameOutput: cdktf.TerraformOutput;
+    readonly tagsOutput: cdktf.TerraformOutput;
+    readonly primaryEndpointsOutput: cdktf.TerraformOutput;
+    readonly id: string;
+    readonly tags: {
+        [key: string]: string;
+    };
+    /**
+     * Creates a new Azure Storage Account using the VersionedAzapiResource framework
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Storage Account
+     */
+    constructor(scope: Construct, id: string, props: StorageAccountProps);
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     */
+    protected defaultVersion(): string;
+    /**
+     * Gets the Azure resource type for Storage Accounts
+     */
+    protected resourceType(): string;
+    /**
+     * Gets the API schema for the resolved version
+     */
+    protected apiSchema(): ApiSchema;
+    /**
+     * Creates the resource body for the Azure API call
+     */
+    protected createResourceBody(props: any): any;
+    /**
+     * Get the primary blob endpoint
+     */
+    get primaryBlobEndpoint(): string;
+    /**
+     * Get the primary file endpoint
+     */
+    get primaryFileEndpoint(): string;
+    /**
+     * Get the primary queue endpoint
+     */
+    get primaryQueueEndpoint(): string;
+    /**
+     * Get the primary table endpoint
+     */
+    get primaryTableEndpoint(): string;
+    /**
+     * Add a tag to the Storage Account
+     */
+    addTag(key: string, value: string): void;
+    /**
+     * Remove a tag from the Storage Account
+     */
+    removeTag(key: string): void;
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    private _applyIgnoreChanges;
+}

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

@@ -0,0 +1,229 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageAccount = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Storage Account implementation using VersionedAzapiResource framework
+ *
+ * This class replaces all version-specific Storage Account implementations with a single
+ * unified class that automatically handles version management, schema validation, and
+ * property transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2023-01-01 (Active)
+ * - 2023-05-01 (Active)
+ * - 2024-01-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full backward compatibility with existing Storage Account interface
+ * - JSII compliance for multi-language support
+ */
+const cdktf = require("cdktf");
+const storage_account_schemas_1 = require("./storage-account-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+/**
+ * Unified Azure Storage Account implementation
+ *
+ * This class provides a single, version-aware implementation that replaces all
+ * version-specific Storage Account classes. It automatically handles version
+ * resolution, schema validation, and property transformation while maintaining
+ * full backward compatibility.
+ *
+ * @example
+ * // Basic usage with automatic version resolution:
+ * const storageAccount = new StorageAccount(this, "storage", {
+ *   name: "mystorageaccount",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "Standard_LRS" },
+ * });
+ *
+ * @example
+ * // Usage with explicit version pinning:
+ * const storageAccount = new StorageAccount(this, "storage", {
+ *   name: "mystorageaccount",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "Standard_LRS" },
+ *   apiVersion: "2023-05-01",
+ * });
+ *
+ * @stability stable
+ */
+class StorageAccount extends azapi_resource_1.AzapiResource {
+    /**
+     * Ensures that Storage Account schemas are registered with the ApiVersionManager
+     */
+    static ensureSchemasRegistered() {
+        if (StorageAccount.schemasRegistered) {
+            return;
+        }
+        const apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            apiVersionManager.registerResourceType(storage_account_schemas_1.STORAGE_ACCOUNT_TYPE, storage_account_schemas_1.ALL_STORAGE_ACCOUNT_VERSIONS);
+            StorageAccount.schemasRegistered = true;
+            console.log(`Registered ${storage_account_schemas_1.ALL_STORAGE_ACCOUNT_VERSIONS.length} API versions for ${storage_account_schemas_1.STORAGE_ACCOUNT_TYPE}`);
+        }
+        catch (error) {
+            console.warn(`Failed to register Storage Account schemas: ${error}. ` +
+                `This may indicate the schemas are already registered or there's a configuration issue.`);
+            StorageAccount.schemasRegistered = true;
+        }
+    }
+    /**
+     * Creates a new Azure Storage Account using the VersionedAzapiResource framework
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Storage Account
+     */
+    constructor(scope, id, props) {
+        // Ensure schemas are registered before calling super
+        StorageAccount.ensureSchemasRegistered();
+        super(scope, id, props);
+        this.props = props;
+        // Extract properties from the AZAPI resource outputs
+        this.id = `\${${this.terraformResource.fqn}.id}`;
+        this.tags = props.tags || {};
+        // Create Terraform outputs
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Storage Account",
+        });
+        this.locationOutput = new cdktf.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.location}`,
+            description: "The location of the Storage Account",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Storage Account",
+        });
+        this.tagsOutput = new cdktf.TerraformOutput(this, "tags", {
+            value: `\${${this.terraformResource.fqn}.tags}`,
+            description: "The tags assigned to the Storage Account",
+        });
+        this.primaryEndpointsOutput = new cdktf.TerraformOutput(this, "primary_endpoints", {
+            value: `\${${this.terraformResource.fqn}.output.properties.primaryEndpoints}`,
+            description: "The primary endpoints of the Storage Account",
+        });
+        // Override logical IDs
+        this.idOutput.overrideLogicalId("id");
+        this.locationOutput.overrideLogicalId("location");
+        this.nameOutput.overrideLogicalId("name");
+        this.tagsOutput.overrideLogicalId("tags");
+        this.primaryEndpointsOutput.overrideLogicalId("primary_endpoints");
+        // Apply ignore changes if specified
+        this._applyIgnoreChanges();
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM VersionedAzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     */
+    defaultVersion() {
+        return "2024-01-01";
+    }
+    /**
+     * Gets the Azure resource type for Storage Accounts
+     */
+    resourceType() {
+        return storage_account_schemas_1.STORAGE_ACCOUNT_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        return {
+            location: typedProps.location || "eastus",
+            tags: typedProps.tags || {},
+            sku: typedProps.sku,
+            kind: typedProps.kind || "StorageV2",
+            properties: {
+                accessTier: typedProps.accessTier || "Hot",
+                supportsHttpsTrafficOnly: typedProps.enableHttpsTrafficOnly !== false,
+                minimumTlsVersion: typedProps.minimumTlsVersion || "TLS1_2",
+                allowBlobPublicAccess: typedProps.allowBlobPublicAccess || false,
+                networkAcls: typedProps.networkAcls,
+                encryption: typedProps.encryption,
+            },
+            identity: typedProps.identity,
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR STORAGE ACCOUNT OPERATIONS
+    // =============================================================================
+    /**
+     * Get the primary blob endpoint
+     */
+    get primaryBlobEndpoint() {
+        return `\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.blob}`;
+    }
+    /**
+     * Get the primary file endpoint
+     */
+    get primaryFileEndpoint() {
+        return `\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.file}`;
+    }
+    /**
+     * Get the primary queue endpoint
+     */
+    get primaryQueueEndpoint() {
+        return `\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.queue}`;
+    }
+    /**
+     * Get the primary table endpoint
+     */
+    get primaryTableEndpoint() {
+        return `\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.table}`;
+    }
+    /**
+     * Add a tag to the Storage Account
+     */
+    addTag(key, value) {
+        if (!this.props.tags) {
+            this.props.tags = {};
+        }
+        this.props.tags[key] = value;
+    }
+    /**
+     * Remove a tag from the Storage Account
+     */
+    removeTag(key) {
+        if (this.props.tags && this.props.tags[key]) {
+            delete this.props.tags[key];
+        }
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    _applyIgnoreChanges() {
+        if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {
+            this.terraformResource.addOverride("lifecycle", [
+                {
+                    ignore_changes: this.props.ignoreChanges,
+                },
+            ]);
+        }
+    }
+}
+exports.StorageAccount = StorageAccount;
+_a = JSII_RTTI_SYMBOL_1;
+StorageAccount[_a] = { fqn: "@microsoft/terraform-cdk-constructs.StorageAccount", version: "1.0.0" };
+StorageAccount.schemasRegistered = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-account.js","sourceRoot":"","sources":["../../../src/azure-storageaccount/lib/storage-account.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Storage Account implementation using VersionedAzapiResource framework\n *\n * This class replaces all version-specific Storage Account implementations with a single\n * unified class that automatically handles version management, schema validation, and\n * property transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2023-01-01 (Active)\n * - 2023-05-01 (Active)\n * - 2024-01-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full backward compatibility with existing Storage Account interface\n * - JSII compliance for multi-language support\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_STORAGE_ACCOUNT_VERSIONS,\n  STORAGE_ACCOUNT_TYPE,\n} from \"./storage-account-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * SKU configuration for Storage Account\n */\nexport interface StorageAccountSku {\n  /**\n   * The SKU name (Standard_LRS, Standard_GRS, Standard_RAGRS, Standard_ZRS, Premium_LRS, Premium_ZRS)\n   */\n  readonly name: string;\n}\n\n/**\n * IP rule for network ACLs\n */\nexport interface StorageAccountIpRule {\n  /**\n   * IP address or CIDR range\n   */\n  readonly value: string;\n}\n\n/**\n * Virtual network rule for network ACLs\n */\nexport interface StorageAccountVirtualNetworkRule {\n  /**\n   * Virtual network resource ID\n   */\n  readonly id: string;\n}\n\n/**\n * Network ACL configuration for Storage Account\n */\nexport interface StorageAccountNetworkAcls {\n  /**\n   * Default action when no rule matches (Allow or Deny)\n   */\n  readonly defaultAction?: string;\n\n  /**\n   * IP rules for the storage account\n   */\n  readonly ipRules?: StorageAccountIpRule[];\n\n  /**\n   * Virtual network rules for the storage account\n   */\n  readonly virtualNetworkRules?: StorageAccountVirtualNetworkRule[];\n\n  /**\n   * Whether to bypass network rules for Azure services\n   */\n  readonly bypass?: string;\n}\n\n/**\n * Identity configuration for Storage Account\n */\nexport interface StorageAccountIdentity {\n  /**\n   * The type of identity (SystemAssigned, UserAssigned, SystemAssigned,UserAssigned)\n   */\n  readonly type: string;\n\n  /**\n   * User assigned identity IDs\n   */\n  readonly userAssignedIdentities?: { [key: string]: any };\n}\n\n/**\n * Encryption service configuration\n */\nexport interface StorageAccountEncryptionService {\n  /**\n   * Whether encryption is enabled\n   */\n  readonly enabled?: boolean;\n}\n\n/**\n * Encryption services configuration\n */\nexport interface StorageAccountEncryptionServices {\n  /**\n   * Blob service encryption\n   */\n  readonly blob?: StorageAccountEncryptionService;\n\n  /**\n   * File service encryption\n   */\n  readonly file?: StorageAccountEncryptionService;\n\n  /**\n   * Table service encryption\n   */\n  readonly table?: StorageAccountEncryptionService;\n\n  /**\n   * Queue service encryption\n   */\n  readonly queue?: StorageAccountEncryptionService;\n}\n\n/**\n * Encryption configuration for Storage Account\n */\nexport interface StorageAccountEncryption {\n  /**\n   * Encryption services (blob, file, table, queue)\n   */\n  readonly services?: StorageAccountEncryptionServices;\n\n  /**\n   * Key source (Microsoft.Storage or Microsoft.Keyvault)\n   */\n  readonly keySource?: string;\n}\n\n/**\n * Properties for the unified Azure Storage Account\n *\n * Extends VersionedAzapiResourceProps with Storage Account specific properties\n */\nexport interface StorageAccountProps extends AzapiResourceProps {\n  /**\n   * The SKU (pricing tier) for the Storage Account\n   * @example { name: \"Standard_LRS\" }\n   */\n  readonly sku: StorageAccountSku;\n\n  /**\n   * The kind of Storage Account\n   * @default \"StorageV2\"\n   * @example \"StorageV2\", \"BlobStorage\", \"BlockBlobStorage\", \"FileStorage\"\n   */\n  readonly kind?: string;\n\n  /**\n   * The access tier for blob storage\n   * @default \"Hot\"\n   * @example \"Hot\", \"Cool\"\n   */\n  readonly accessTier?: string;\n\n  /**\n   * Whether to allow only HTTPS traffic\n   * @default true\n   */\n  readonly enableHttpsTrafficOnly?: boolean;\n\n  /**\n   * The minimum TLS version required\n   * @default \"TLS1_2\"\n   */\n  readonly minimumTlsVersion?: string;\n\n  /**\n   * Whether to allow public access to blobs\n   * @default false\n   */\n  readonly allowBlobPublicAccess?: boolean;\n\n  /**\n   * Network ACL rules for the storage account\n   */\n  readonly networkAcls?: StorageAccountNetworkAcls;\n\n  /**\n   * Managed identity configuration\n   */\n  readonly identity?: StorageAccountIdentity;\n\n  /**\n   * Encryption settings\n   */\n  readonly encryption?: StorageAccountEncryption;\n\n  /**\n   * The lifecycle rules to ignore changes\n   * @example [\"tags\"]\n   */\n  readonly ignoreChanges?: string[];\n\n  /**\n   * Resource group ID where the storage account will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Storage Account properties for the request body\n */\nexport interface StorageAccountBodyProperties {\n  readonly accessTier?: string;\n  readonly supportsHttpsTrafficOnly?: boolean;\n  readonly minimumTlsVersion?: string;\n  readonly allowBlobPublicAccess?: boolean;\n  readonly networkAcls?: StorageAccountNetworkAcls;\n  readonly encryption?: StorageAccountEncryption;\n}\n\n/**\n * The resource body interface for Azure Storage Account API calls\n */\nexport interface StorageAccountBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly sku: StorageAccountSku;\n  readonly kind: string;\n  readonly properties?: StorageAccountBodyProperties;\n  readonly identity?: StorageAccountIdentity;\n}\n\n/**\n * Unified Azure Storage Account implementation\n *\n * This class provides a single, version-aware implementation that replaces all\n * version-specific Storage Account classes. It automatically handles version\n * resolution, schema validation, and property transformation while maintaining\n * full backward compatibility.\n *\n * @example\n * // Basic usage with automatic version resolution:\n * const storageAccount = new StorageAccount(this, \"storage\", {\n *   name: \"mystorageaccount\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   sku: { name: \"Standard_LRS\" },\n * });\n *\n * @example\n * // Usage with explicit version pinning:\n * const storageAccount = new StorageAccount(this, \"storage\", {\n *   name: \"mystorageaccount\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n *   sku: { name: \"Standard_LRS\" },\n *   apiVersion: \"2023-05-01\",\n * });\n *\n * @stability stable\n */\nexport class StorageAccount extends AzapiResource {\n  private static schemasRegistered = false;\n\n  /**\n   * Ensures that Storage Account schemas are registered with the ApiVersionManager\n   */\n  private static ensureSchemasRegistered(): void {\n    if (StorageAccount.schemasRegistered) {\n      return;\n    }\n\n    const apiVersionManager = ApiVersionManager.instance();\n\n    try {\n      apiVersionManager.registerResourceType(\n        STORAGE_ACCOUNT_TYPE,\n        ALL_STORAGE_ACCOUNT_VERSIONS,\n      );\n\n      StorageAccount.schemasRegistered = true;\n\n      console.log(\n        `Registered ${ALL_STORAGE_ACCOUNT_VERSIONS.length} API versions for ${STORAGE_ACCOUNT_TYPE}`,\n      );\n    } catch (error) {\n      console.warn(\n        `Failed to register Storage Account schemas: ${error}. ` +\n          `This may indicate the schemas are already registered or there's a configuration issue.`,\n      );\n      StorageAccount.schemasRegistered = true;\n    }\n  }\n\n  public readonly props: StorageAccountProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly locationOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly tagsOutput: cdktf.TerraformOutput;\n  public readonly primaryEndpointsOutput: cdktf.TerraformOutput;\n\n  // Public properties\n  public readonly id: string;\n  public readonly tags: { [key: string]: string };\n\n  /**\n   * Creates a new Azure Storage Account using the VersionedAzapiResource framework\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Storage Account\n   */\n  constructor(scope: Construct, id: string, props: StorageAccountProps) {\n    // Ensure schemas are registered before calling super\n    StorageAccount.ensureSchemasRegistered();\n\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs\n    this.id = `\\${${this.terraformResource.fqn}.id}`;\n    this.tags = props.tags || {};\n\n    // Create Terraform outputs\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Storage Account\",\n    });\n\n    this.locationOutput = new cdktf.TerraformOutput(this, \"location\", {\n      value: `\\${${this.terraformResource.fqn}.location}`,\n      description: \"The location of the Storage Account\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Storage Account\",\n    });\n\n    this.tagsOutput = new cdktf.TerraformOutput(this, \"tags\", {\n      value: `\\${${this.terraformResource.fqn}.tags}`,\n      description: \"The tags assigned to the Storage Account\",\n    });\n\n    this.primaryEndpointsOutput = new cdktf.TerraformOutput(\n      this,\n      \"primary_endpoints\",\n      {\n        value: `\\${${this.terraformResource.fqn}.output.properties.primaryEndpoints}`,\n        description: \"The primary endpoints of the Storage Account\",\n      },\n    );\n\n    // Override logical IDs\n    this.idOutput.overrideLogicalId(\"id\");\n    this.locationOutput.overrideLogicalId(\"location\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.tagsOutput.overrideLogicalId(\"tags\");\n    this.primaryEndpointsOutput.overrideLogicalId(\"primary_endpoints\");\n\n    // Apply ignore changes if specified\n    this._applyIgnoreChanges();\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM VersionedAzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   */\n  protected defaultVersion(): string {\n    return \"2024-01-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Storage Accounts\n   */\n  protected resourceType(): string {\n    return STORAGE_ACCOUNT_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as StorageAccountProps;\n    return {\n      location: typedProps.location || \"eastus\",\n      tags: typedProps.tags || {},\n      sku: typedProps.sku,\n      kind: typedProps.kind || \"StorageV2\",\n      properties: {\n        accessTier: typedProps.accessTier || \"Hot\",\n        supportsHttpsTrafficOnly: typedProps.enableHttpsTrafficOnly !== false,\n        minimumTlsVersion: typedProps.minimumTlsVersion || \"TLS1_2\",\n        allowBlobPublicAccess: typedProps.allowBlobPublicAccess || false,\n        networkAcls: typedProps.networkAcls,\n        encryption: typedProps.encryption,\n      },\n      identity: typedProps.identity,\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR STORAGE ACCOUNT OPERATIONS\n  // =============================================================================\n\n  /**\n   * Get the primary blob endpoint\n   */\n  public get primaryBlobEndpoint(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.blob}`;\n  }\n\n  /**\n   * Get the primary file endpoint\n   */\n  public get primaryFileEndpoint(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.file}`;\n  }\n\n  /**\n   * Get the primary queue endpoint\n   */\n  public get primaryQueueEndpoint(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.queue}`;\n  }\n\n  /**\n   * Get the primary table endpoint\n   */\n  public get primaryTableEndpoint(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.primaryEndpoints.table}`;\n  }\n\n  /**\n   * Add a tag to the Storage Account\n   */\n  public addTag(key: string, value: string): void {\n    if (!this.props.tags) {\n      (this.props as any).tags = {};\n    }\n    this.props.tags![key] = value;\n  }\n\n  /**\n   * Remove a tag from the Storage Account\n   */\n  public removeTag(key: string): void {\n    if (this.props.tags && this.props.tags[key]) {\n      delete this.props.tags[key];\n    }\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Applies ignore changes lifecycle rules if specified in props\n   */\n  private _applyIgnoreChanges(): void {\n    if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {\n      this.terraformResource.addOverride(\"lifecycle\", [\n        {\n          ignore_changes: this.props.ignoreChanges,\n        },\n      ]);\n    }\n  }\n}\n"]}

package/lib/azure-storageaccount/test/storage-account.integ.d.ts

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

package/lib/azure-storageaccount/test/storage-account.integ.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Integration test for Azure Storage Account
+ *
+ * This test demonstrates basic usage of the StorageAccount construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const storage_account_1 = require("../lib/storage-account");
+/**
+ * Example stack demonstrating Storage Account usage
+ */
+class StorageAccountExampleStack extends cdktf_1.TerraformStack {
+    constructor(scope, id) {
+        super(scope, id);
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Create a resource group
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: "storage-example-rg",
+            location: "eastus",
+            tags: {
+                environment: "example",
+                purpose: "integration-test",
+            },
+        });
+        // Example 1: Basic storage account
+        new storage_account_1.StorageAccount(this, "basic-storage", {
+            name: "basicstorageexample",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: { name: "Standard_LRS" },
+            tags: {
+                example: "basic",
+            },
+        });
+        // Example 2: Storage account with specific version
+        new storage_account_1.StorageAccount(this, "versioned-storage", {
+            name: "versionedstorageex",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: { name: "Standard_GRS" },
+            apiVersion: "2023-05-01",
+            tags: {
+                example: "versioned",
+            },
+        });
+    }
+}
+describe("Storage Account Integration Test", () => {
+    afterAll(() => {
+        (0, testing_1.cleanupCdkTfOutDirs)();
+    });
+    it("should deploy, validate idempotency, and cleanup storage account resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new StorageAccountExampleStack(app, "test-storage-account");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized);
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS1hY2NvdW50LmludGVnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F6dXJlLXN0b3JhZ2VhY2NvdW50L3Rlc3Qvc3RvcmFnZS1hY2NvdW50LmludGVnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7OztHQU9HOztBQUVILGlDQUFnRDtBQUVoRCwyQ0FBeUM7QUFDekMsbUVBQTBEO0FBQzFELGtGQUFvRjtBQUNwRiwyQ0FHdUI7QUFDdkIsNERBQXdEO0FBRXhEOztHQUVHO0FBQ0gsTUFBTSwwQkFBMkIsU0FBUSxzQkFBYztJQUNyRCxZQUFZLEtBQWdCLEVBQUUsRUFBVTtRQUN0QyxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLDJCQUEyQjtRQUMzQixJQUFJLHdCQUFhLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQztRQUVyQywwQkFBMEI7UUFDMUIsTUFBTSxhQUFhLEdBQUcsSUFBSSxtQ0FBYSxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUU7WUFDMUQsSUFBSSxFQUFFLG9CQUFvQjtZQUMxQixRQUFRLEVBQUUsUUFBUTtZQUNsQixJQUFJLEVBQUU7Z0JBQ0osV0FBVyxFQUFFLFNBQVM7Z0JBQ3RCLE9BQU8sRUFBRSxrQkFBa0I7YUFDNUI7U0FDRixDQUFDLENBQUM7UUFFSCxtQ0FBbUM7UUFDbkMsSUFBSSxnQ0FBYyxDQUFDLElBQUksRUFBRSxlQUFlLEVBQUU7WUFDeEMsSUFBSSxFQUFFLHFCQUFxQjtZQUMzQixRQUFRLEVBQUUsYUFBYSxDQUFDLEtBQUssQ0FBQyxRQUFTO1lBQ3ZDLGVBQWUsRUFBRSxhQUFhLENBQUMsRUFBRTtZQUNqQyxHQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUUsY0FBYyxFQUFFO1lBQzdCLElBQUksRUFBRTtnQkFDSixPQUFPLEVBQUUsT0FBTzthQUNqQjtTQUNGLENBQUMsQ0FBQztRQUVILG1EQUFtRDtRQUNuRCxJQUFJLGdDQUFjLENBQUMsSUFBSSxFQUFFLG1CQUFtQixFQUFFO1lBQzVDLElBQUksRUFBRSxvQkFBb0I7WUFDMUIsUUFBUSxFQUFFLGFBQWEsQ0FBQyxLQUFLLENBQUMsUUFBUztZQUN2QyxlQUFlLEVBQUUsYUFBYSxDQUFDLEVBQUU7WUFDakMsR0FBRyxFQUFFLEVBQUUsSUFBSSxFQUFFLGNBQWMsRUFBRTtZQUM3QixVQUFVLEVBQUUsWUFBWTtZQUN4QixJQUFJLEVBQUU7Z0JBQ0osT0FBTyxFQUFFLFdBQVc7YUFDckI7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUFFRCxRQUFRLENBQUMsa0NBQWtDLEVBQUUsR0FBRyxFQUFFO0lBQ2hELFFBQVEsQ0FBQyxHQUFHLEVBQUU7UUFDWixJQUFBLDZCQUFtQixHQUFFLENBQUM7SUFDeEIsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsNEVBQTRFLEVBQUUsR0FBRyxFQUFFO1FBQ3BGLE1BQU0sR0FBRyxHQUFHLGVBQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUMxQixNQUFNLEtBQUssR0FBRyxJQUFJLDBCQUEwQixDQUFDLEdBQUcsRUFBRSxzQkFBc0IsQ0FBQyxDQUFDO1FBQzFFLE1BQU0sV0FBVyxHQUFHLGVBQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFN0MsYUFBYTtRQUNiLDZDQUE2QztRQUM3QyxtRUFBbUU7UUFDbkUsZ0RBQWdEO1FBQ2hELElBQUEsdUNBQTZCLEVBQUMsV0FBVyxDQUFDLENBQUM7SUFDN0MsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsK0NBQStDO0FBQzdELENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBJbnRlZ3JhdGlvbiB0ZXN0IGZvciBBenVyZSBTdG9yYWdlIEFjY291bnRcbiAqXG4gKiBUaGlzIHRlc3QgZGVtb25zdHJhdGVzIGJhc2ljIHVzYWdlIG9mIHRoZSBTdG9yYWdlQWNjb3VudCBjb25zdHJ1Y3RcbiAqIGFuZCB2YWxpZGF0ZXMgZGVwbG95bWVudCwgaWRlbXBvdGVuY3ksIGFuZCBjbGVhbnVwLlxuICpcbiAqIFJ1biB3aXRoOiBucG0gcnVuIGludGVncmF0aW9uOm5vc3RyZWFtXG4gKi9cblxuaW1wb3J0IHsgVGVzdGluZywgVGVycmFmb3JtU3RhY2sgfSBmcm9tIFwiY2RrdGZcIjtcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5pbXBvcnQgXCJjZGt0Zi9saWIvdGVzdGluZy9hZGFwdGVycy9qZXN0XCI7XG5pbXBvcnQgeyBSZXNvdXJjZUdyb3VwIH0gZnJvbSBcIi4uLy4uL2F6dXJlLXJlc291cmNlZ3JvdXBcIjtcbmltcG9ydCB7IEF6YXBpUHJvdmlkZXIgfSBmcm9tIFwiLi4vLi4vY29yZS1henVyZS9saWIvYXphcGkvcHJvdmlkZXJzLWF6YXBpL3Byb3ZpZGVyXCI7XG5pbXBvcnQge1xuICBUZXJyYWZvcm1BcHBseUNoZWNrQW5kRGVzdHJveSxcbiAgY2xlYW51cENka1RmT3V0RGlycyxcbn0gZnJvbSBcIi4uLy4uL3Rlc3RpbmdcIjtcbmltcG9ydCB7IFN0b3JhZ2VBY2NvdW50IH0gZnJvbSBcIi4uL2xpYi9zdG9yYWdlLWFjY291bnRcIjtcblxuLyoqXG4gKiBFeGFtcGxlIHN0YWNrIGRlbW9uc3RyYXRpbmcgU3RvcmFnZSBBY2NvdW50IHVzYWdlXG4gKi9cbmNsYXNzIFN0b3JhZ2VBY2NvdW50RXhhbXBsZVN0YWNrIGV4dGVuZHMgVGVycmFmb3JtU3RhY2sge1xuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIC8vIENvbmZpZ3VyZSBBWkFQSSBwcm92aWRlclxuICAgIG5ldyBBemFwaVByb3ZpZGVyKHRoaXMsIFwiYXphcGlcIiwge30pO1xuXG4gICAgLy8gQ3JlYXRlIGEgcmVzb3VyY2UgZ3JvdXBcbiAgICBjb25zdCByZXNvdXJjZUdyb3VwID0gbmV3IFJlc291cmNlR3JvdXAodGhpcywgXCJleGFtcGxlLXJnXCIsIHtcbiAgICAgIG5hbWU6IFwic3RvcmFnZS1leGFtcGxlLXJnXCIsXG4gICAgICBsb2NhdGlvbjogXCJlYXN0dXNcIixcbiAgICAgIHRhZ3M6IHtcbiAgICAgICAgZW52aXJvbm1lbnQ6IFwiZXhhbXBsZVwiLFxuICAgICAgICBwdXJwb3NlOiBcImludGVncmF0aW9uLXRlc3RcIixcbiAgICAgIH0sXG4gICAgfSk7XG5cbiAgICAvLyBFeGFtcGxlIDE6IEJhc2ljIHN0b3JhZ2UgYWNjb3VudFxuICAgIG5ldyBTdG9yYWdlQWNjb3VudCh0aGlzLCBcImJhc2ljLXN0b3JhZ2VcIiwge1xuICAgICAgbmFtZTogXCJiYXNpY3N0b3JhZ2VleGFtcGxlXCIsXG4gICAgICBsb2NhdGlvbjogcmVzb3VyY2VHcm91cC5wcm9wcy5sb2NhdGlvbiEsXG4gICAgICByZXNvdXJjZUdyb3VwSWQ6IHJlc291cmNlR3JvdXAuaWQsXG4gICAgICBza3U6IHsgbmFtZTogXCJTdGFuZGFyZF9MUlNcIiB9LFxuICAgICAgdGFnczoge1xuICAgICAgICBleGFtcGxlOiBcImJhc2ljXCIsXG4gICAgICB9LFxuICAgIH0pO1xuXG4gICAgLy8gRXhhbXBsZSAyOiBTdG9yYWdlIGFjY291bnQgd2l0aCBzcGVjaWZpYyB2ZXJzaW9uXG4gICAgbmV3IFN0b3JhZ2VBY2NvdW50KHRoaXMsIFwidmVyc2lvbmVkLXN0b3JhZ2VcIiwge1xuICAgICAgbmFtZTogXCJ2ZXJzaW9uZWRzdG9yYWdlZXhcIixcbiAgICAgIGxvY2F0aW9uOiByZXNvdXJjZUdyb3VwLnByb3BzLmxvY2F0aW9uISxcbiAgICAgIHJlc291cmNlR3JvdXBJZDogcmVzb3VyY2VHcm91cC5pZCxcbiAgICAgIHNrdTogeyBuYW1lOiBcIlN0YW5kYXJkX0dSU1wiIH0sXG4gICAgICBhcGlWZXJzaW9uOiBcIjIwMjMtMDUtMDFcIixcbiAgICAgIHRhZ3M6IHtcbiAgICAgICAgZXhhbXBsZTogXCJ2ZXJzaW9uZWRcIixcbiAgICAgIH0sXG4gICAgfSk7XG4gIH1cbn1cblxuZGVzY3JpYmUoXCJTdG9yYWdlIEFjY291bnQgSW50ZWdyYXRpb24gVGVzdFwiLCAoKSA9PiB7XG4gIGFmdGVyQWxsKCgpID0+IHtcbiAgICBjbGVhbnVwQ2RrVGZPdXREaXJzKCk7XG4gIH0pO1xuXG4gIGl0KFwic2hvdWxkIGRlcGxveSwgdmFsaWRhdGUgaWRlbXBvdGVuY3ksIGFuZCBjbGVhbnVwIHN0b3JhZ2UgYWNjb3VudCByZXNvdXJjZXNcIiwgKCkgPT4ge1xuICAgIGNvbnN0IGFwcCA9IFRlc3RpbmcuYXBwKCk7XG4gICAgY29uc3Qgc3RhY2sgPSBuZXcgU3RvcmFnZUFjY291bnRFeGFtcGxlU3RhY2soYXBwLCBcInRlc3Qtc3RvcmFnZS1hY2NvdW50XCIpO1xuICAgIGNvbnN0IHN5bnRoZXNpemVkID0gVGVzdGluZy5mdWxsU3ludGgoc3RhY2spO1xuXG4gICAgLy8gVGhpcyB3aWxsOlxuICAgIC8vIDEuIFJ1biB0ZXJyYWZvcm0gYXBwbHkgdG8gZGVwbG95IHJlc291cmNlc1xuICAgIC8vIDIuIFJ1biB0ZXJyYWZvcm0gcGxhbiB0byBjaGVjayBpZGVtcG90ZW5jeSAobm8gY2hhbmdlcyBleHBlY3RlZClcbiAgICAvLyAzLiBSdW4gdGVycmFmb3JtIGRlc3Ryb3kgdG8gY2xlYW51cCByZXNvdXJjZXNcbiAgICBUZXJyYWZvcm1BcHBseUNoZWNrQW5kRGVzdHJveShzeW50aGVzaXplZCk7XG4gIH0sIDYwMDAwMCk7IC8vIDEwIG1pbnV0ZSB0aW1lb3V0IGZvciBkZXBsb3ltZW50IGFuZCBjbGVhbnVwXG59KTtcbiJdfQ==