# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'AccountAzureFilesAuthentication',
    'AccountAzureFilesAuthenticationActiveDirectory',
    'AccountBlobProperties',
    'AccountBlobPropertiesContainerDeleteRetentionPolicy',
    'AccountBlobPropertiesCorsRule',
    'AccountBlobPropertiesDeleteRetentionPolicy',
    'AccountCustomDomain',
    'AccountIdentity',
    'AccountNetworkRules',
    'AccountNetworkRulesPrivateLinkAccess',
    'AccountNetworkRulesPrivateLinkAccessRule',
    'AccountQueueProperties',
    'AccountQueuePropertiesCorsRule',
    'AccountQueuePropertiesHourMetrics',
    'AccountQueuePropertiesLogging',
    'AccountQueuePropertiesMinuteMetrics',
    'AccountRouting',
    'AccountStaticWebsite',
    'BlobInventoryPolicyRule',
    'BlobInventoryPolicyRuleFilter',
    'DataLakeGen2FilesystemAce',
    'DataLakeGen2PathAce',
    'ManagementPolicyRule',
    'ManagementPolicyRuleActions',
    'ManagementPolicyRuleActionsBaseBlob',
    'ManagementPolicyRuleActionsSnapshot',
    'ManagementPolicyRuleActionsVersion',
    'ManagementPolicyRuleFilters',
    'ManagementPolicyRuleFiltersMatchBlobIndexTag',
    'ShareAcl',
    'ShareAclAccessPolicy',
    'TableAcl',
    'TableAclAccessPolicy',
    'GetAccountBlobContainerSASPermissionsResult',
    'GetAccountCustomDomainResult',
    'GetAccountSASPermissionsResult',
    'GetAccountSASResourceTypesResult',
    'GetAccountSASServicesResult',
    'GetPolicyRuleResult',
    'GetPolicyRuleActionResult',
    'GetPolicyRuleActionBaseBlobResult',
    'GetPolicyRuleActionSnapshotResult',
    'GetPolicyRuleActionVersionResult',
    'GetPolicyRuleFilterResult',
    'GetPolicyRuleFilterMatchBlobIndexTagResult',
]

@pulumi.output_type
class AccountAzureFilesAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "directoryType":
            suggest = "directory_type"
        elif key == "activeDirectory":
            suggest = "active_directory"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountAzureFilesAuthentication. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountAzureFilesAuthentication.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountAzureFilesAuthentication.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 directory_type: str,
                 active_directory: Optional['outputs.AccountAzureFilesAuthenticationActiveDirectory'] = None):
        """
        :param str directory_type: Specifies the directory service used. Possible values are `AADDS` and `AD`.
        :param 'AccountAzureFilesAuthenticationActiveDirectoryArgs' active_directory: A `active_directory` block as defined below. Required when `directory_type` is `AD`.
        """
        pulumi.set(__self__, "directory_type", directory_type)
        if active_directory is not None:
            pulumi.set(__self__, "active_directory", active_directory)

    @property
    @pulumi.getter(name="directoryType")
    def directory_type(self) -> str:
        """
        Specifies the directory service used. Possible values are `AADDS` and `AD`.
        """
        return pulumi.get(self, "directory_type")

    @property
    @pulumi.getter(name="activeDirectory")
    def active_directory(self) -> Optional['outputs.AccountAzureFilesAuthenticationActiveDirectory']:
        """
        A `active_directory` block as defined below. Required when `directory_type` is `AD`.
        """
        return pulumi.get(self, "active_directory")


@pulumi.output_type
class AccountAzureFilesAuthenticationActiveDirectory(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "domainGuid":
            suggest = "domain_guid"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "domainSid":
            suggest = "domain_sid"
        elif key == "forestName":
            suggest = "forest_name"
        elif key == "netbiosDomainName":
            suggest = "netbios_domain_name"
        elif key == "storageSid":
            suggest = "storage_sid"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountAzureFilesAuthenticationActiveDirectory. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountAzureFilesAuthenticationActiveDirectory.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountAzureFilesAuthenticationActiveDirectory.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 domain_guid: str,
                 domain_name: str,
                 domain_sid: str,
                 forest_name: str,
                 netbios_domain_name: str,
                 storage_sid: str):
        """
        :param str domain_guid: Specifies the domain GUID.
        :param str domain_name: Specifies the primary domain that the AD DNS server is authoritative for.
        :param str domain_sid: Specifies the security identifier (SID).
        :param str forest_name: Specifies the Active Directory forest.
        :param str netbios_domain_name: Specifies the NetBIOS domain name.
        :param str storage_sid: Specifies the security identifier (SID) for Azure Storage.
        """
        pulumi.set(__self__, "domain_guid", domain_guid)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "domain_sid", domain_sid)
        pulumi.set(__self__, "forest_name", forest_name)
        pulumi.set(__self__, "netbios_domain_name", netbios_domain_name)
        pulumi.set(__self__, "storage_sid", storage_sid)

    @property
    @pulumi.getter(name="domainGuid")
    def domain_guid(self) -> str:
        """
        Specifies the domain GUID.
        """
        return pulumi.get(self, "domain_guid")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        """
        Specifies the primary domain that the AD DNS server is authoritative for.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="domainSid")
    def domain_sid(self) -> str:
        """
        Specifies the security identifier (SID).
        """
        return pulumi.get(self, "domain_sid")

    @property
    @pulumi.getter(name="forestName")
    def forest_name(self) -> str:
        """
        Specifies the Active Directory forest.
        """
        return pulumi.get(self, "forest_name")

    @property
    @pulumi.getter(name="netbiosDomainName")
    def netbios_domain_name(self) -> str:
        """
        Specifies the NetBIOS domain name.
        """
        return pulumi.get(self, "netbios_domain_name")

    @property
    @pulumi.getter(name="storageSid")
    def storage_sid(self) -> str:
        """
        Specifies the security identifier (SID) for Azure Storage.
        """
        return pulumi.get(self, "storage_sid")


@pulumi.output_type
class AccountBlobProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "changeFeedEnabled":
            suggest = "change_feed_enabled"
        elif key == "containerDeleteRetentionPolicy":
            suggest = "container_delete_retention_policy"
        elif key == "corsRules":
            suggest = "cors_rules"
        elif key == "defaultServiceVersion":
            suggest = "default_service_version"
        elif key == "deleteRetentionPolicy":
            suggest = "delete_retention_policy"
        elif key == "lastAccessTimeEnabled":
            suggest = "last_access_time_enabled"
        elif key == "versioningEnabled":
            suggest = "versioning_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountBlobProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountBlobProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountBlobProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 change_feed_enabled: Optional[bool] = None,
                 container_delete_retention_policy: Optional['outputs.AccountBlobPropertiesContainerDeleteRetentionPolicy'] = None,
                 cors_rules: Optional[Sequence['outputs.AccountBlobPropertiesCorsRule']] = None,
                 default_service_version: Optional[str] = None,
                 delete_retention_policy: Optional['outputs.AccountBlobPropertiesDeleteRetentionPolicy'] = None,
                 last_access_time_enabled: Optional[bool] = None,
                 versioning_enabled: Optional[bool] = None):
        """
        :param bool change_feed_enabled: Is the blob service properties for change feed events enabled? Default to `false`.
        :param 'AccountBlobPropertiesContainerDeleteRetentionPolicyArgs' container_delete_retention_policy: A `container_delete_retention_policy` block as defined below.
        :param Sequence['AccountBlobPropertiesCorsRuleArgs'] cors_rules: A `cors_rule` block as defined below.
        :param str default_service_version: The API Version which should be used by default for requests to the Data Plane API if an incoming request doesn't specify an API Version. Defaults to `2020-06-12`.
        :param 'AccountBlobPropertiesDeleteRetentionPolicyArgs' delete_retention_policy: A `delete_retention_policy` block as defined below.
        :param bool last_access_time_enabled: Is the last access time based tracking enabled? Default to `false`.
        :param bool versioning_enabled: Is versioning enabled? Default to `false`.
        """
        if change_feed_enabled is not None:
            pulumi.set(__self__, "change_feed_enabled", change_feed_enabled)
        if container_delete_retention_policy is not None:
            pulumi.set(__self__, "container_delete_retention_policy", container_delete_retention_policy)
        if cors_rules is not None:
            pulumi.set(__self__, "cors_rules", cors_rules)
        if default_service_version is not None:
            pulumi.set(__self__, "default_service_version", default_service_version)
        if delete_retention_policy is not None:
            pulumi.set(__self__, "delete_retention_policy", delete_retention_policy)
        if last_access_time_enabled is not None:
            pulumi.set(__self__, "last_access_time_enabled", last_access_time_enabled)
        if versioning_enabled is not None:
            pulumi.set(__self__, "versioning_enabled", versioning_enabled)

    @property
    @pulumi.getter(name="changeFeedEnabled")
    def change_feed_enabled(self) -> Optional[bool]:
        """
        Is the blob service properties for change feed events enabled? Default to `false`.
        """
        return pulumi.get(self, "change_feed_enabled")

    @property
    @pulumi.getter(name="containerDeleteRetentionPolicy")
    def container_delete_retention_policy(self) -> Optional['outputs.AccountBlobPropertiesContainerDeleteRetentionPolicy']:
        """
        A `container_delete_retention_policy` block as defined below.
        """
        return pulumi.get(self, "container_delete_retention_policy")

    @property
    @pulumi.getter(name="corsRules")
    def cors_rules(self) -> Optional[Sequence['outputs.AccountBlobPropertiesCorsRule']]:
        """
        A `cors_rule` block as defined below.
        """
        return pulumi.get(self, "cors_rules")

    @property
    @pulumi.getter(name="defaultServiceVersion")
    def default_service_version(self) -> Optional[str]:
        """
        The API Version which should be used by default for requests to the Data Plane API if an incoming request doesn't specify an API Version. Defaults to `2020-06-12`.
        """
        return pulumi.get(self, "default_service_version")

    @property
    @pulumi.getter(name="deleteRetentionPolicy")
    def delete_retention_policy(self) -> Optional['outputs.AccountBlobPropertiesDeleteRetentionPolicy']:
        """
        A `delete_retention_policy` block as defined below.
        """
        return pulumi.get(self, "delete_retention_policy")

    @property
    @pulumi.getter(name="lastAccessTimeEnabled")
    def last_access_time_enabled(self) -> Optional[bool]:
        """
        Is the last access time based tracking enabled? Default to `false`.
        """
        return pulumi.get(self, "last_access_time_enabled")

    @property
    @pulumi.getter(name="versioningEnabled")
    def versioning_enabled(self) -> Optional[bool]:
        """
        Is versioning enabled? Default to `false`.
        """
        return pulumi.get(self, "versioning_enabled")


@pulumi.output_type
class AccountBlobPropertiesContainerDeleteRetentionPolicy(dict):
    def __init__(__self__, *,
                 days: Optional[int] = None):
        """
        :param int days: Specifies the number of days that the container should be retained, between `1` and `365` days. Defaults to `7`.
        """
        if days is not None:
            pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        Specifies the number of days that the container should be retained, between `1` and `365` days. Defaults to `7`.
        """
        return pulumi.get(self, "days")


@pulumi.output_type
class AccountBlobPropertiesCorsRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHeaders":
            suggest = "allowed_headers"
        elif key == "allowedMethods":
            suggest = "allowed_methods"
        elif key == "allowedOrigins":
            suggest = "allowed_origins"
        elif key == "exposedHeaders":
            suggest = "exposed_headers"
        elif key == "maxAgeInSeconds":
            suggest = "max_age_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountBlobPropertiesCorsRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountBlobPropertiesCorsRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountBlobPropertiesCorsRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_headers: Sequence[str],
                 allowed_methods: Sequence[str],
                 allowed_origins: Sequence[str],
                 exposed_headers: Sequence[str],
                 max_age_in_seconds: int):
        """
        :param Sequence[str] allowed_headers: A list of headers that are allowed to be a part of the cross-origin request.
        :param Sequence[str] allowed_methods: A list of http headers that are allowed to be executed by the origin. Valid options are
               `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        :param Sequence[str] allowed_origins: A list of origin domains that will be allowed by CORS.
        :param Sequence[str] exposed_headers: A list of response headers that are exposed to CORS clients.
        :param int max_age_in_seconds: The number of seconds the client should cache a preflight response.
        """
        pulumi.set(__self__, "allowed_headers", allowed_headers)
        pulumi.set(__self__, "allowed_methods", allowed_methods)
        pulumi.set(__self__, "allowed_origins", allowed_origins)
        pulumi.set(__self__, "exposed_headers", exposed_headers)
        pulumi.set(__self__, "max_age_in_seconds", max_age_in_seconds)

    @property
    @pulumi.getter(name="allowedHeaders")
    def allowed_headers(self) -> Sequence[str]:
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        return pulumi.get(self, "allowed_headers")

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> Sequence[str]:
        """
        A list of http headers that are allowed to be executed by the origin. Valid options are
        `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        """
        return pulumi.get(self, "allowed_methods")

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> Sequence[str]:
        """
        A list of origin domains that will be allowed by CORS.
        """
        return pulumi.get(self, "allowed_origins")

    @property
    @pulumi.getter(name="exposedHeaders")
    def exposed_headers(self) -> Sequence[str]:
        """
        A list of response headers that are exposed to CORS clients.
        """
        return pulumi.get(self, "exposed_headers")

    @property
    @pulumi.getter(name="maxAgeInSeconds")
    def max_age_in_seconds(self) -> int:
        """
        The number of seconds the client should cache a preflight response.
        """
        return pulumi.get(self, "max_age_in_seconds")


@pulumi.output_type
class AccountBlobPropertiesDeleteRetentionPolicy(dict):
    def __init__(__self__, *,
                 days: Optional[int] = None):
        """
        :param int days: Specifies the number of days that the blob should be retained, between `1` and `365` days. Defaults to `7`.
        """
        if days is not None:
            pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        Specifies the number of days that the blob should be retained, between `1` and `365` days. Defaults to `7`.
        """
        return pulumi.get(self, "days")


@pulumi.output_type
class AccountCustomDomain(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "useSubdomain":
            suggest = "use_subdomain"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountCustomDomain. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountCustomDomain.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountCustomDomain.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 use_subdomain: Optional[bool] = None):
        """
        :param str name: The Custom Domain Name to use for the Storage Account, which will be validated by Azure.
        :param bool use_subdomain: Should the Custom Domain Name be validated by using indirect CNAME validation?
        """
        pulumi.set(__self__, "name", name)
        if use_subdomain is not None:
            pulumi.set(__self__, "use_subdomain", use_subdomain)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Custom Domain Name to use for the Storage Account, which will be validated by Azure.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="useSubdomain")
    def use_subdomain(self) -> Optional[bool]:
        """
        Should the Custom Domain Name be validated by using indirect CNAME validation?
        """
        return pulumi.get(self, "use_subdomain")


@pulumi.output_type
class AccountIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: Specifies the identity type of the Storage Account. At this time the only allowed value is `SystemAssigned`.
        :param str principal_id: The Principal ID for the Service Principal associated with the Identity of this Storage Account.
        :param str tenant_id: The Tenant ID for the Service Principal associated with the Identity of this Storage Account.
        """
        pulumi.set(__self__, "type", type)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the identity type of the Storage Account. At this time the only allowed value is `SystemAssigned`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        """
        The Principal ID for the Service Principal associated with the Identity of this Storage Account.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The Tenant ID for the Service Principal associated with the Identity of this Storage Account.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class AccountNetworkRules(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultAction":
            suggest = "default_action"
        elif key == "ipRules":
            suggest = "ip_rules"
        elif key == "privateLinkAccesses":
            suggest = "private_link_accesses"
        elif key == "virtualNetworkSubnetIds":
            suggest = "virtual_network_subnet_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountNetworkRules. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountNetworkRules.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountNetworkRules.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_action: str,
                 bypasses: Optional[Sequence[str]] = None,
                 ip_rules: Optional[Sequence[str]] = None,
                 private_link_accesses: Optional[Sequence['outputs.AccountNetworkRulesPrivateLinkAccess']] = None,
                 virtual_network_subnet_ids: Optional[Sequence[str]] = None):
        """
        :param str default_action: Specifies the default action of allow or deny when no other rules match. Valid options are `Deny` or `Allow`.
        :param Sequence[str] bypasses: Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Valid options are
               any combination of `Logging`, `Metrics`, `AzureServices`, or `None`.
        :param Sequence[str] ip_rules: List of public IP or IP ranges in CIDR Format. Only IPV4 addresses are allowed. Private IP address ranges (as defined in [RFC 1918](https://tools.ietf.org/html/rfc1918#section-3)) are not allowed.
        :param Sequence['AccountNetworkRulesPrivateLinkAccessArgs'] private_link_accesses: One or More `private_link_access` block as defined below.
        :param Sequence[str] virtual_network_subnet_ids: A list of resource ids for subnets.
        """
        pulumi.set(__self__, "default_action", default_action)
        if bypasses is not None:
            pulumi.set(__self__, "bypasses", bypasses)
        if ip_rules is not None:
            pulumi.set(__self__, "ip_rules", ip_rules)
        if private_link_accesses is not None:
            pulumi.set(__self__, "private_link_accesses", private_link_accesses)
        if virtual_network_subnet_ids is not None:
            pulumi.set(__self__, "virtual_network_subnet_ids", virtual_network_subnet_ids)

    @property
    @pulumi.getter(name="defaultAction")
    def default_action(self) -> str:
        """
        Specifies the default action of allow or deny when no other rules match. Valid options are `Deny` or `Allow`.
        """
        return pulumi.get(self, "default_action")

    @property
    @pulumi.getter
    def bypasses(self) -> Optional[Sequence[str]]:
        """
        Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Valid options are
        any combination of `Logging`, `Metrics`, `AzureServices`, or `None`.
        """
        return pulumi.get(self, "bypasses")

    @property
    @pulumi.getter(name="ipRules")
    def ip_rules(self) -> Optional[Sequence[str]]:
        """
        List of public IP or IP ranges in CIDR Format. Only IPV4 addresses are allowed. Private IP address ranges (as defined in [RFC 1918](https://tools.ietf.org/html/rfc1918#section-3)) are not allowed.
        """
        return pulumi.get(self, "ip_rules")

    @property
    @pulumi.getter(name="privateLinkAccesses")
    def private_link_accesses(self) -> Optional[Sequence['outputs.AccountNetworkRulesPrivateLinkAccess']]:
        """
        One or More `private_link_access` block as defined below.
        """
        return pulumi.get(self, "private_link_accesses")

    @property
    @pulumi.getter(name="virtualNetworkSubnetIds")
    def virtual_network_subnet_ids(self) -> Optional[Sequence[str]]:
        """
        A list of resource ids for subnets.
        """
        return pulumi.get(self, "virtual_network_subnet_ids")


@pulumi.output_type
class AccountNetworkRulesPrivateLinkAccess(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointResourceId":
            suggest = "endpoint_resource_id"
        elif key == "endpointTenantId":
            suggest = "endpoint_tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountNetworkRulesPrivateLinkAccess. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountNetworkRulesPrivateLinkAccess.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountNetworkRulesPrivateLinkAccess.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 endpoint_resource_id: str,
                 endpoint_tenant_id: Optional[str] = None):
        """
        :param str endpoint_resource_id: The resource id of the `privatelink.Endpoint` of the resource access rule.
        :param str endpoint_tenant_id: The tenant id of the `privatelink.Endpoint` of the resource access rule. Defaults to the current tenant id.
        """
        pulumi.set(__self__, "endpoint_resource_id", endpoint_resource_id)
        if endpoint_tenant_id is not None:
            pulumi.set(__self__, "endpoint_tenant_id", endpoint_tenant_id)

    @property
    @pulumi.getter(name="endpointResourceId")
    def endpoint_resource_id(self) -> str:
        """
        The resource id of the `privatelink.Endpoint` of the resource access rule.
        """
        return pulumi.get(self, "endpoint_resource_id")

    @property
    @pulumi.getter(name="endpointTenantId")
    def endpoint_tenant_id(self) -> Optional[str]:
        """
        The tenant id of the `privatelink.Endpoint` of the resource access rule. Defaults to the current tenant id.
        """
        return pulumi.get(self, "endpoint_tenant_id")


@pulumi.output_type
class AccountNetworkRulesPrivateLinkAccessRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointResourceId":
            suggest = "endpoint_resource_id"
        elif key == "endpointTenantId":
            suggest = "endpoint_tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountNetworkRulesPrivateLinkAccessRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountNetworkRulesPrivateLinkAccessRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountNetworkRulesPrivateLinkAccessRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 endpoint_resource_id: str,
                 endpoint_tenant_id: Optional[str] = None):
        """
        :param str endpoint_resource_id: The resource id of the `privatelink.Endpoint` of the resource access rule.
        :param str endpoint_tenant_id: The tenant id of the `privatelink.Endpoint` of the resource access rule. Defaults to the current tenant id.
        """
        pulumi.set(__self__, "endpoint_resource_id", endpoint_resource_id)
        if endpoint_tenant_id is not None:
            pulumi.set(__self__, "endpoint_tenant_id", endpoint_tenant_id)

    @property
    @pulumi.getter(name="endpointResourceId")
    def endpoint_resource_id(self) -> str:
        """
        The resource id of the `privatelink.Endpoint` of the resource access rule.
        """
        return pulumi.get(self, "endpoint_resource_id")

    @property
    @pulumi.getter(name="endpointTenantId")
    def endpoint_tenant_id(self) -> Optional[str]:
        """
        The tenant id of the `privatelink.Endpoint` of the resource access rule. Defaults to the current tenant id.
        """
        return pulumi.get(self, "endpoint_tenant_id")


@pulumi.output_type
class AccountQueueProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "corsRules":
            suggest = "cors_rules"
        elif key == "hourMetrics":
            suggest = "hour_metrics"
        elif key == "minuteMetrics":
            suggest = "minute_metrics"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountQueueProperties. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountQueueProperties.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountQueueProperties.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cors_rules: Optional[Sequence['outputs.AccountQueuePropertiesCorsRule']] = None,
                 hour_metrics: Optional['outputs.AccountQueuePropertiesHourMetrics'] = None,
                 logging: Optional['outputs.AccountQueuePropertiesLogging'] = None,
                 minute_metrics: Optional['outputs.AccountQueuePropertiesMinuteMetrics'] = None):
        """
        :param Sequence['AccountQueuePropertiesCorsRuleArgs'] cors_rules: A `cors_rule` block as defined above.
        :param 'AccountQueuePropertiesHourMetricsArgs' hour_metrics: A `hour_metrics` block as defined below.
        :param 'AccountQueuePropertiesLoggingArgs' logging: A `logging` block as defined below.
        :param 'AccountQueuePropertiesMinuteMetricsArgs' minute_metrics: A `minute_metrics` block as defined below.
        """
        if cors_rules is not None:
            pulumi.set(__self__, "cors_rules", cors_rules)
        if hour_metrics is not None:
            pulumi.set(__self__, "hour_metrics", hour_metrics)
        if logging is not None:
            pulumi.set(__self__, "logging", logging)
        if minute_metrics is not None:
            pulumi.set(__self__, "minute_metrics", minute_metrics)

    @property
    @pulumi.getter(name="corsRules")
    def cors_rules(self) -> Optional[Sequence['outputs.AccountQueuePropertiesCorsRule']]:
        """
        A `cors_rule` block as defined above.
        """
        return pulumi.get(self, "cors_rules")

    @property
    @pulumi.getter(name="hourMetrics")
    def hour_metrics(self) -> Optional['outputs.AccountQueuePropertiesHourMetrics']:
        """
        A `hour_metrics` block as defined below.
        """
        return pulumi.get(self, "hour_metrics")

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.AccountQueuePropertiesLogging']:
        """
        A `logging` block as defined below.
        """
        return pulumi.get(self, "logging")

    @property
    @pulumi.getter(name="minuteMetrics")
    def minute_metrics(self) -> Optional['outputs.AccountQueuePropertiesMinuteMetrics']:
        """
        A `minute_metrics` block as defined below.
        """
        return pulumi.get(self, "minute_metrics")


@pulumi.output_type
class AccountQueuePropertiesCorsRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHeaders":
            suggest = "allowed_headers"
        elif key == "allowedMethods":
            suggest = "allowed_methods"
        elif key == "allowedOrigins":
            suggest = "allowed_origins"
        elif key == "exposedHeaders":
            suggest = "exposed_headers"
        elif key == "maxAgeInSeconds":
            suggest = "max_age_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountQueuePropertiesCorsRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountQueuePropertiesCorsRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountQueuePropertiesCorsRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_headers: Sequence[str],
                 allowed_methods: Sequence[str],
                 allowed_origins: Sequence[str],
                 exposed_headers: Sequence[str],
                 max_age_in_seconds: int):
        """
        :param Sequence[str] allowed_headers: A list of headers that are allowed to be a part of the cross-origin request.
        :param Sequence[str] allowed_methods: A list of http headers that are allowed to be executed by the origin. Valid options are
               `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        :param Sequence[str] allowed_origins: A list of origin domains that will be allowed by CORS.
        :param Sequence[str] exposed_headers: A list of response headers that are exposed to CORS clients.
        :param int max_age_in_seconds: The number of seconds the client should cache a preflight response.
        """
        pulumi.set(__self__, "allowed_headers", allowed_headers)
        pulumi.set(__self__, "allowed_methods", allowed_methods)
        pulumi.set(__self__, "allowed_origins", allowed_origins)
        pulumi.set(__self__, "exposed_headers", exposed_headers)
        pulumi.set(__self__, "max_age_in_seconds", max_age_in_seconds)

    @property
    @pulumi.getter(name="allowedHeaders")
    def allowed_headers(self) -> Sequence[str]:
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        return pulumi.get(self, "allowed_headers")

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> Sequence[str]:
        """
        A list of http headers that are allowed to be executed by the origin. Valid options are
        `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        """
        return pulumi.get(self, "allowed_methods")

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> Sequence[str]:
        """
        A list of origin domains that will be allowed by CORS.
        """
        return pulumi.get(self, "allowed_origins")

    @property
    @pulumi.getter(name="exposedHeaders")
    def exposed_headers(self) -> Sequence[str]:
        """
        A list of response headers that are exposed to CORS clients.
        """
        return pulumi.get(self, "exposed_headers")

    @property
    @pulumi.getter(name="maxAgeInSeconds")
    def max_age_in_seconds(self) -> int:
        """
        The number of seconds the client should cache a preflight response.
        """
        return pulumi.get(self, "max_age_in_seconds")


@pulumi.output_type
class AccountQueuePropertiesHourMetrics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includeApis":
            suggest = "include_apis"
        elif key == "retentionPolicyDays":
            suggest = "retention_policy_days"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountQueuePropertiesHourMetrics. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountQueuePropertiesHourMetrics.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountQueuePropertiesHourMetrics.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 version: str,
                 include_apis: Optional[bool] = None,
                 retention_policy_days: Optional[int] = None):
        """
        :param bool enabled: Indicates whether hour metrics are enabled for the Queue service. Changing this forces a new resource.
        :param str version: The version of storage analytics to configure. Changing this forces a new resource.
        :param bool include_apis: Indicates whether metrics should generate summary statistics for called API operations.
        :param int retention_policy_days: Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "version", version)
        if include_apis is not None:
            pulumi.set(__self__, "include_apis", include_apis)
        if retention_policy_days is not None:
            pulumi.set(__self__, "retention_policy_days", retention_policy_days)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether hour metrics are enabled for the Queue service. Changing this forces a new resource.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The version of storage analytics to configure. Changing this forces a new resource.
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="includeApis")
    def include_apis(self) -> Optional[bool]:
        """
        Indicates whether metrics should generate summary statistics for called API operations.
        """
        return pulumi.get(self, "include_apis")

    @property
    @pulumi.getter(name="retentionPolicyDays")
    def retention_policy_days(self) -> Optional[int]:
        """
        Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        return pulumi.get(self, "retention_policy_days")


@pulumi.output_type
class AccountQueuePropertiesLogging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPolicyDays":
            suggest = "retention_policy_days"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountQueuePropertiesLogging. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountQueuePropertiesLogging.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountQueuePropertiesLogging.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete: bool,
                 read: bool,
                 version: str,
                 write: bool,
                 retention_policy_days: Optional[int] = None):
        """
        :param bool delete: Indicates whether all delete requests should be logged. Changing this forces a new resource.
        :param bool read: Indicates whether all read requests should be logged. Changing this forces a new resource.
        :param str version: The version of storage analytics to configure. Changing this forces a new resource.
        :param bool write: Indicates whether all write requests should be logged. Changing this forces a new resource.
        :param int retention_policy_days: Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        pulumi.set(__self__, "delete", delete)
        pulumi.set(__self__, "read", read)
        pulumi.set(__self__, "version", version)
        pulumi.set(__self__, "write", write)
        if retention_policy_days is not None:
            pulumi.set(__self__, "retention_policy_days", retention_policy_days)

    @property
    @pulumi.getter
    def delete(self) -> bool:
        """
        Indicates whether all delete requests should be logged. Changing this forces a new resource.
        """
        return pulumi.get(self, "delete")

    @property
    @pulumi.getter
    def read(self) -> bool:
        """
        Indicates whether all read requests should be logged. Changing this forces a new resource.
        """
        return pulumi.get(self, "read")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The version of storage analytics to configure. Changing this forces a new resource.
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter
    def write(self) -> bool:
        """
        Indicates whether all write requests should be logged. Changing this forces a new resource.
        """
        return pulumi.get(self, "write")

    @property
    @pulumi.getter(name="retentionPolicyDays")
    def retention_policy_days(self) -> Optional[int]:
        """
        Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        return pulumi.get(self, "retention_policy_days")


@pulumi.output_type
class AccountQueuePropertiesMinuteMetrics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includeApis":
            suggest = "include_apis"
        elif key == "retentionPolicyDays":
            suggest = "retention_policy_days"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountQueuePropertiesMinuteMetrics. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountQueuePropertiesMinuteMetrics.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountQueuePropertiesMinuteMetrics.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 version: str,
                 include_apis: Optional[bool] = None,
                 retention_policy_days: Optional[int] = None):
        """
        :param bool enabled: Indicates whether minute metrics are enabled for the Queue service. Changing this forces a new resource.
        :param str version: The version of storage analytics to configure. Changing this forces a new resource.
        :param bool include_apis: Indicates whether metrics should generate summary statistics for called API operations.
        :param int retention_policy_days: Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "version", version)
        if include_apis is not None:
            pulumi.set(__self__, "include_apis", include_apis)
        if retention_policy_days is not None:
            pulumi.set(__self__, "retention_policy_days", retention_policy_days)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether minute metrics are enabled for the Queue service. Changing this forces a new resource.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The version of storage analytics to configure. Changing this forces a new resource.
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="includeApis")
    def include_apis(self) -> Optional[bool]:
        """
        Indicates whether metrics should generate summary statistics for called API operations.
        """
        return pulumi.get(self, "include_apis")

    @property
    @pulumi.getter(name="retentionPolicyDays")
    def retention_policy_days(self) -> Optional[int]:
        """
        Specifies the number of days that logs will be retained. Changing this forces a new resource.
        """
        return pulumi.get(self, "retention_policy_days")


@pulumi.output_type
class AccountRouting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "publishInternetEndpoints":
            suggest = "publish_internet_endpoints"
        elif key == "publishMicrosoftEndpoints":
            suggest = "publish_microsoft_endpoints"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountRouting. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountRouting.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountRouting.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 choice: Optional[str] = None,
                 publish_internet_endpoints: Optional[bool] = None,
                 publish_microsoft_endpoints: Optional[bool] = None):
        """
        :param str choice: Specifies the kind of network routing opted by the user. Possible values are `InternetRouting` and `MicrosoftRouting`. Defaults to `MicrosoftRouting`.
        :param bool publish_internet_endpoints: Should internet routing storage endpoints be published? Defaults to `false`.
        :param bool publish_microsoft_endpoints: Should microsoft routing storage endpoints be published? Defaults to `false`.
        """
        if choice is not None:
            pulumi.set(__self__, "choice", choice)
        if publish_internet_endpoints is not None:
            pulumi.set(__self__, "publish_internet_endpoints", publish_internet_endpoints)
        if publish_microsoft_endpoints is not None:
            pulumi.set(__self__, "publish_microsoft_endpoints", publish_microsoft_endpoints)

    @property
    @pulumi.getter
    def choice(self) -> Optional[str]:
        """
        Specifies the kind of network routing opted by the user. Possible values are `InternetRouting` and `MicrosoftRouting`. Defaults to `MicrosoftRouting`.
        """
        return pulumi.get(self, "choice")

    @property
    @pulumi.getter(name="publishInternetEndpoints")
    def publish_internet_endpoints(self) -> Optional[bool]:
        """
        Should internet routing storage endpoints be published? Defaults to `false`.
        """
        return pulumi.get(self, "publish_internet_endpoints")

    @property
    @pulumi.getter(name="publishMicrosoftEndpoints")
    def publish_microsoft_endpoints(self) -> Optional[bool]:
        """
        Should microsoft routing storage endpoints be published? Defaults to `false`.
        """
        return pulumi.get(self, "publish_microsoft_endpoints")


@pulumi.output_type
class AccountStaticWebsite(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "error404Document":
            suggest = "error404_document"
        elif key == "indexDocument":
            suggest = "index_document"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountStaticWebsite. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountStaticWebsite.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountStaticWebsite.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 error404_document: Optional[str] = None,
                 index_document: Optional[str] = None):
        """
        :param str error404_document: The absolute path to a custom webpage that should be used when a request is made which does not correspond to an existing file.
        :param str index_document: The webpage that Azure Storage serves for requests to the root of a website or any subfolder. For example, index.html. The value is case-sensitive.
        """
        if error404_document is not None:
            pulumi.set(__self__, "error404_document", error404_document)
        if index_document is not None:
            pulumi.set(__self__, "index_document", index_document)

    @property
    @pulumi.getter(name="error404Document")
    def error404_document(self) -> Optional[str]:
        """
        The absolute path to a custom webpage that should be used when a request is made which does not correspond to an existing file.
        """
        return pulumi.get(self, "error404_document")

    @property
    @pulumi.getter(name="indexDocument")
    def index_document(self) -> Optional[str]:
        """
        The webpage that Azure Storage serves for requests to the root of a website or any subfolder. For example, index.html. The value is case-sensitive.
        """
        return pulumi.get(self, "index_document")


@pulumi.output_type
class BlobInventoryPolicyRule(dict):
    def __init__(__self__, *,
                 filter: 'outputs.BlobInventoryPolicyRuleFilter',
                 name: str):
        """
        :param 'BlobInventoryPolicyRuleFilterArgs' filter: A `filter` block as defined above.
        :param str name: The name which should be used for this Blob Inventory Policy Rule.
        """
        pulumi.set(__self__, "filter", filter)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def filter(self) -> 'outputs.BlobInventoryPolicyRuleFilter':
        """
        A `filter` block as defined above.
        """
        return pulumi.get(self, "filter")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this Blob Inventory Policy Rule.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class BlobInventoryPolicyRuleFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blobTypes":
            suggest = "blob_types"
        elif key == "includeBlobVersions":
            suggest = "include_blob_versions"
        elif key == "includeSnapshots":
            suggest = "include_snapshots"
        elif key == "prefixMatches":
            suggest = "prefix_matches"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BlobInventoryPolicyRuleFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BlobInventoryPolicyRuleFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BlobInventoryPolicyRuleFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 blob_types: Sequence[str],
                 include_blob_versions: Optional[bool] = None,
                 include_snapshots: Optional[bool] = None,
                 prefix_matches: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] blob_types: A set of blob types. Possible values are `blockBlob`, `appendBlob`, and `pageBlob`. The storage account with `is_hns_enabled` is `true` doesn't support `pageBlob`.
        :param bool include_blob_versions: Includes blob versions in blob inventory or not? Defaults to `false`.
        :param bool include_snapshots: Includes blob snapshots in blob inventory or not? Defaults to `false`.
        :param Sequence[str] prefix_matches: A set of strings for blob prefixes to be matched.
        """
        pulumi.set(__self__, "blob_types", blob_types)
        if include_blob_versions is not None:
            pulumi.set(__self__, "include_blob_versions", include_blob_versions)
        if include_snapshots is not None:
            pulumi.set(__self__, "include_snapshots", include_snapshots)
        if prefix_matches is not None:
            pulumi.set(__self__, "prefix_matches", prefix_matches)

    @property
    @pulumi.getter(name="blobTypes")
    def blob_types(self) -> Sequence[str]:
        """
        A set of blob types. Possible values are `blockBlob`, `appendBlob`, and `pageBlob`. The storage account with `is_hns_enabled` is `true` doesn't support `pageBlob`.
        """
        return pulumi.get(self, "blob_types")

    @property
    @pulumi.getter(name="includeBlobVersions")
    def include_blob_versions(self) -> Optional[bool]:
        """
        Includes blob versions in blob inventory or not? Defaults to `false`.
        """
        return pulumi.get(self, "include_blob_versions")

    @property
    @pulumi.getter(name="includeSnapshots")
    def include_snapshots(self) -> Optional[bool]:
        """
        Includes blob snapshots in blob inventory or not? Defaults to `false`.
        """
        return pulumi.get(self, "include_snapshots")

    @property
    @pulumi.getter(name="prefixMatches")
    def prefix_matches(self) -> Optional[Sequence[str]]:
        """
        A set of strings for blob prefixes to be matched.
        """
        return pulumi.get(self, "prefix_matches")


@pulumi.output_type
class DataLakeGen2FilesystemAce(dict):
    def __init__(__self__, *,
                 permissions: str,
                 type: str,
                 id: Optional[str] = None,
                 scope: Optional[str] = None):
        """
        :param str permissions: Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        :param str type: Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        :param str id: Specifies the Object ID of the Azure Active Directory User or Group that the entry relates to. Only valid for `user` or `group` entries.
        :param str scope: Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "type", type)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def permissions(self) -> str:
        """
        Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        """
        return pulumi.get(self, "permissions")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Specifies the Object ID of the Azure Active Directory User or Group that the entry relates to. Only valid for `user` or `group` entries.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def scope(self) -> Optional[str]:
        """
        Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class DataLakeGen2PathAce(dict):
    def __init__(__self__, *,
                 permissions: str,
                 type: str,
                 id: Optional[str] = None,
                 scope: Optional[str] = None):
        """
        :param str permissions: Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        :param str type: Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        :param str id: Specifies the Object ID of the Azure Active Directory User or Group that the entry relates to. Only valid for `user` or `group` entries.
        :param str scope: Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "type", type)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def permissions(self) -> str:
        """
        Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        """
        return pulumi.get(self, "permissions")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Specifies the Object ID of the Azure Active Directory User or Group that the entry relates to. Only valid for `user` or `group` entries.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def scope(self) -> Optional[str]:
        """
        Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class ManagementPolicyRule(dict):
    def __init__(__self__, *,
                 actions: 'outputs.ManagementPolicyRuleActions',
                 enabled: bool,
                 name: str,
                 filters: Optional['outputs.ManagementPolicyRuleFilters'] = None):
        """
        :param 'ManagementPolicyRuleActionsArgs' actions: An `actions` block as documented below.
        :param bool enabled: Boolean to specify whether the rule is enabled.
        :param str name: A rule name can contain any combination of alpha numeric characters. Rule name is case-sensitive. It must be unique within a policy.
        :param 'ManagementPolicyRuleFiltersArgs' filters: A `filter` block as documented below.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "name", name)
        if filters is not None:
            pulumi.set(__self__, "filters", filters)

    @property
    @pulumi.getter
    def actions(self) -> 'outputs.ManagementPolicyRuleActions':
        """
        An `actions` block as documented below.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Boolean to specify whether the rule is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A rule name can contain any combination of alpha numeric characters. Rule name is case-sensitive. It must be unique within a policy.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def filters(self) -> Optional['outputs.ManagementPolicyRuleFilters']:
        """
        A `filter` block as documented below.
        """
        return pulumi.get(self, "filters")


@pulumi.output_type
class ManagementPolicyRuleActions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseBlob":
            suggest = "base_blob"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementPolicyRuleActions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementPolicyRuleActions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementPolicyRuleActions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 base_blob: Optional['outputs.ManagementPolicyRuleActionsBaseBlob'] = None,
                 snapshot: Optional['outputs.ManagementPolicyRuleActionsSnapshot'] = None,
                 version: Optional['outputs.ManagementPolicyRuleActionsVersion'] = None):
        """
        :param 'ManagementPolicyRuleActionsBaseBlobArgs' base_blob: A `base_blob` block as documented below.
        :param 'ManagementPolicyRuleActionsSnapshotArgs' snapshot: A `snapshot` block as documented below.
        :param 'ManagementPolicyRuleActionsVersionArgs' version: A `version` block as documented below.
        """
        if base_blob is not None:
            pulumi.set(__self__, "base_blob", base_blob)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="baseBlob")
    def base_blob(self) -> Optional['outputs.ManagementPolicyRuleActionsBaseBlob']:
        """
        A `base_blob` block as documented below.
        """
        return pulumi.get(self, "base_blob")

    @property
    @pulumi.getter
    def snapshot(self) -> Optional['outputs.ManagementPolicyRuleActionsSnapshot']:
        """
        A `snapshot` block as documented below.
        """
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter
    def version(self) -> Optional['outputs.ManagementPolicyRuleActionsVersion']:
        """
        A `version` block as documented below.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class ManagementPolicyRuleActionsBaseBlob(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteAfterDaysSinceModificationGreaterThan":
            suggest = "delete_after_days_since_modification_greater_than"
        elif key == "tierToArchiveAfterDaysSinceModificationGreaterThan":
            suggest = "tier_to_archive_after_days_since_modification_greater_than"
        elif key == "tierToCoolAfterDaysSinceModificationGreaterThan":
            suggest = "tier_to_cool_after_days_since_modification_greater_than"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementPolicyRuleActionsBaseBlob. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementPolicyRuleActionsBaseBlob.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementPolicyRuleActionsBaseBlob.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_after_days_since_modification_greater_than: Optional[int] = None,
                 tier_to_archive_after_days_since_modification_greater_than: Optional[int] = None,
                 tier_to_cool_after_days_since_modification_greater_than: Optional[int] = None):
        """
        :param int delete_after_days_since_modification_greater_than: The age in days after last modification to delete the blob. Must be between 0 and 99999.
        :param int tier_to_archive_after_days_since_modification_greater_than: The age in days after last modification to tier blobs to archive storage. Supports blob currently at Hot or Cool tier. Must be between 0 and 99999.
        :param int tier_to_cool_after_days_since_modification_greater_than: The age in days after last modification to tier blobs to cool storage. Supports blob currently at Hot tier. Must be between 0 and 99999.
        """
        if delete_after_days_since_modification_greater_than is not None:
            pulumi.set(__self__, "delete_after_days_since_modification_greater_than", delete_after_days_since_modification_greater_than)
        if tier_to_archive_after_days_since_modification_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_modification_greater_than", tier_to_archive_after_days_since_modification_greater_than)
        if tier_to_cool_after_days_since_modification_greater_than is not None:
            pulumi.set(__self__, "tier_to_cool_after_days_since_modification_greater_than", tier_to_cool_after_days_since_modification_greater_than)

    @property
    @pulumi.getter(name="deleteAfterDaysSinceModificationGreaterThan")
    def delete_after_days_since_modification_greater_than(self) -> Optional[int]:
        """
        The age in days after last modification to delete the blob. Must be between 0 and 99999.
        """
        return pulumi.get(self, "delete_after_days_since_modification_greater_than")

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceModificationGreaterThan")
    def tier_to_archive_after_days_since_modification_greater_than(self) -> Optional[int]:
        """
        The age in days after last modification to tier blobs to archive storage. Supports blob currently at Hot or Cool tier. Must be between 0 and 99999.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_modification_greater_than")

    @property
    @pulumi.getter(name="tierToCoolAfterDaysSinceModificationGreaterThan")
    def tier_to_cool_after_days_since_modification_greater_than(self) -> Optional[int]:
        """
        The age in days after last modification to tier blobs to cool storage. Supports blob currently at Hot tier. Must be between 0 and 99999.
        """
        return pulumi.get(self, "tier_to_cool_after_days_since_modification_greater_than")


@pulumi.output_type
class ManagementPolicyRuleActionsSnapshot(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "changeTierToArchiveAfterDaysSinceCreation":
            suggest = "change_tier_to_archive_after_days_since_creation"
        elif key == "changeTierToCoolAfterDaysSinceCreation":
            suggest = "change_tier_to_cool_after_days_since_creation"
        elif key == "deleteAfterDaysSinceCreationGreaterThan":
            suggest = "delete_after_days_since_creation_greater_than"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementPolicyRuleActionsSnapshot. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementPolicyRuleActionsSnapshot.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementPolicyRuleActionsSnapshot.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: Optional[int] = None,
                 change_tier_to_cool_after_days_since_creation: Optional[int] = None,
                 delete_after_days_since_creation_greater_than: Optional[int] = None):
        """
        :param int change_tier_to_archive_after_days_since_creation: The age in days after creation to tier blob snapshot to archive storage. Must be between 0 and 99999.
        :param int change_tier_to_cool_after_days_since_creation: The age in days after creation to tier blob snapshot to cool storage. Must be between 0 and 99999.
        :param int delete_after_days_since_creation_greater_than: The age in days after creation to delete the blob snapshot. Must be between 0 and 99999.
        """
        if change_tier_to_archive_after_days_since_creation is not None:
            pulumi.set(__self__, "change_tier_to_archive_after_days_since_creation", change_tier_to_archive_after_days_since_creation)
        if change_tier_to_cool_after_days_since_creation is not None:
            pulumi.set(__self__, "change_tier_to_cool_after_days_since_creation", change_tier_to_cool_after_days_since_creation)
        if delete_after_days_since_creation_greater_than is not None:
            pulumi.set(__self__, "delete_after_days_since_creation_greater_than", delete_after_days_since_creation_greater_than)

    @property
    @pulumi.getter(name="changeTierToArchiveAfterDaysSinceCreation")
    def change_tier_to_archive_after_days_since_creation(self) -> Optional[int]:
        """
        The age in days after creation to tier blob snapshot to archive storage. Must be between 0 and 99999.
        """
        return pulumi.get(self, "change_tier_to_archive_after_days_since_creation")

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> Optional[int]:
        """
        The age in days after creation to tier blob snapshot to cool storage. Must be between 0 and 99999.
        """
        return pulumi.get(self, "change_tier_to_cool_after_days_since_creation")

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreationGreaterThan")
    def delete_after_days_since_creation_greater_than(self) -> Optional[int]:
        """
        The age in days after creation to delete the blob snapshot. Must be between 0 and 99999.
        """
        return pulumi.get(self, "delete_after_days_since_creation_greater_than")


@pulumi.output_type
class ManagementPolicyRuleActionsVersion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "changeTierToArchiveAfterDaysSinceCreation":
            suggest = "change_tier_to_archive_after_days_since_creation"
        elif key == "changeTierToCoolAfterDaysSinceCreation":
            suggest = "change_tier_to_cool_after_days_since_creation"
        elif key == "deleteAfterDaysSinceCreation":
            suggest = "delete_after_days_since_creation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementPolicyRuleActionsVersion. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementPolicyRuleActionsVersion.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementPolicyRuleActionsVersion.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: Optional[int] = None,
                 change_tier_to_cool_after_days_since_creation: Optional[int] = None,
                 delete_after_days_since_creation: Optional[int] = None):
        """
        :param int change_tier_to_archive_after_days_since_creation: The age in days after creation to tier blob version to archive storage. Must be between 0 and 99999.
        :param int change_tier_to_cool_after_days_since_creation: The age in days creation create to  tier blob version to cool storage. Must be between 0 and 99999.
        :param int delete_after_days_since_creation: The age in days after creation to delete the blob version. Must be between 0 and 99999.
        """
        if change_tier_to_archive_after_days_since_creation is not None:
            pulumi.set(__self__, "change_tier_to_archive_after_days_since_creation", change_tier_to_archive_after_days_since_creation)
        if change_tier_to_cool_after_days_since_creation is not None:
            pulumi.set(__self__, "change_tier_to_cool_after_days_since_creation", change_tier_to_cool_after_days_since_creation)
        if delete_after_days_since_creation is not None:
            pulumi.set(__self__, "delete_after_days_since_creation", delete_after_days_since_creation)

    @property
    @pulumi.getter(name="changeTierToArchiveAfterDaysSinceCreation")
    def change_tier_to_archive_after_days_since_creation(self) -> Optional[int]:
        """
        The age in days after creation to tier blob version to archive storage. Must be between 0 and 99999.
        """
        return pulumi.get(self, "change_tier_to_archive_after_days_since_creation")

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> Optional[int]:
        """
        The age in days creation create to  tier blob version to cool storage. Must be between 0 and 99999.
        """
        return pulumi.get(self, "change_tier_to_cool_after_days_since_creation")

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreation")
    def delete_after_days_since_creation(self) -> Optional[int]:
        """
        The age in days after creation to delete the blob version. Must be between 0 and 99999.
        """
        return pulumi.get(self, "delete_after_days_since_creation")


@pulumi.output_type
class ManagementPolicyRuleFilters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blobTypes":
            suggest = "blob_types"
        elif key == "matchBlobIndexTags":
            suggest = "match_blob_index_tags"
        elif key == "prefixMatches":
            suggest = "prefix_matches"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ManagementPolicyRuleFilters. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ManagementPolicyRuleFilters.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ManagementPolicyRuleFilters.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 blob_types: Optional[Sequence[str]] = None,
                 match_blob_index_tags: Optional[Sequence['outputs.ManagementPolicyRuleFiltersMatchBlobIndexTag']] = None,
                 prefix_matches: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] blob_types: An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        :param Sequence['ManagementPolicyRuleFiltersMatchBlobIndexTagArgs'] match_blob_index_tags: A `match_blob_index_tag` block as defined below. The block defines the blob index tag based filtering for blob objects.
        :param Sequence[str] prefix_matches: An array of strings for prefixes to be matched.
        """
        if blob_types is not None:
            pulumi.set(__self__, "blob_types", blob_types)
        if match_blob_index_tags is not None:
            pulumi.set(__self__, "match_blob_index_tags", match_blob_index_tags)
        if prefix_matches is not None:
            pulumi.set(__self__, "prefix_matches", prefix_matches)

    @property
    @pulumi.getter(name="blobTypes")
    def blob_types(self) -> Optional[Sequence[str]]:
        """
        An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        """
        return pulumi.get(self, "blob_types")

    @property
    @pulumi.getter(name="matchBlobIndexTags")
    def match_blob_index_tags(self) -> Optional[Sequence['outputs.ManagementPolicyRuleFiltersMatchBlobIndexTag']]:
        """
        A `match_blob_index_tag` block as defined below. The block defines the blob index tag based filtering for blob objects.
        """
        return pulumi.get(self, "match_blob_index_tags")

    @property
    @pulumi.getter(name="prefixMatches")
    def prefix_matches(self) -> Optional[Sequence[str]]:
        """
        An array of strings for prefixes to be matched.
        """
        return pulumi.get(self, "prefix_matches")


@pulumi.output_type
class ManagementPolicyRuleFiltersMatchBlobIndexTag(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str,
                 operation: Optional[str] = None):
        """
        :param str name: The filter tag name used for tag based filtering for blob objects.
        :param str value: The filter tag value used for tag based filtering for blob objects.
        :param str operation: The comparison operator which is used for object comparison and filtering. Possible value is `==`. Defaults to `==`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)
        if operation is not None:
            pulumi.set(__self__, "operation", operation)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The filter tag name used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The filter tag value used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def operation(self) -> Optional[str]:
        """
        The comparison operator which is used for object comparison and filtering. Possible value is `==`. Defaults to `==`.
        """
        return pulumi.get(self, "operation")


@pulumi.output_type
class ShareAcl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessPolicies":
            suggest = "access_policies"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ShareAcl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ShareAcl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ShareAcl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 access_policies: Optional[Sequence['outputs.ShareAclAccessPolicy']] = None):
        """
        :param str id: The ID which should be used for this Shared Identifier.
        :param Sequence['ShareAclAccessPolicyArgs'] access_policies: An `access_policy` block as defined below.
        """
        pulumi.set(__self__, "id", id)
        if access_policies is not None:
            pulumi.set(__self__, "access_policies", access_policies)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID which should be used for this Shared Identifier.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="accessPolicies")
    def access_policies(self) -> Optional[Sequence['outputs.ShareAclAccessPolicy']]:
        """
        An `access_policy` block as defined below.
        """
        return pulumi.get(self, "access_policies")


@pulumi.output_type
class ShareAclAccessPolicy(dict):
    def __init__(__self__, *,
                 permissions: str,
                 expiry: Optional[str] = None,
                 start: Optional[str] = None):
        """
        :param str permissions: The permissions which should be associated with this Shared Identifier. Possible value is combination of `r` (read), `w` (write), `d` (delete), and `l` (list).
        :param str expiry: The time at which this Access Policy should be valid until, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        :param str start: The time at which this Access Policy should be valid from, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        """
        pulumi.set(__self__, "permissions", permissions)
        if expiry is not None:
            pulumi.set(__self__, "expiry", expiry)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def permissions(self) -> str:
        """
        The permissions which should be associated with this Shared Identifier. Possible value is combination of `r` (read), `w` (write), `d` (delete), and `l` (list).
        """
        return pulumi.get(self, "permissions")

    @property
    @pulumi.getter
    def expiry(self) -> Optional[str]:
        """
        The time at which this Access Policy should be valid until, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        """
        return pulumi.get(self, "expiry")

    @property
    @pulumi.getter
    def start(self) -> Optional[str]:
        """
        The time at which this Access Policy should be valid from, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class TableAcl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessPolicies":
            suggest = "access_policies"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TableAcl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TableAcl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TableAcl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 access_policies: Optional[Sequence['outputs.TableAclAccessPolicy']] = None):
        """
        :param str id: The ID which should be used for this Shared Identifier.
        :param Sequence['TableAclAccessPolicyArgs'] access_policies: An `access_policy` block as defined below.
        """
        pulumi.set(__self__, "id", id)
        if access_policies is not None:
            pulumi.set(__self__, "access_policies", access_policies)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID which should be used for this Shared Identifier.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="accessPolicies")
    def access_policies(self) -> Optional[Sequence['outputs.TableAclAccessPolicy']]:
        """
        An `access_policy` block as defined below.
        """
        return pulumi.get(self, "access_policies")


@pulumi.output_type
class TableAclAccessPolicy(dict):
    def __init__(__self__, *,
                 expiry: str,
                 permissions: str,
                 start: str):
        """
        :param str expiry: The ISO8061 UTC time at which this Access Policy should be valid until.
        :param str permissions: The permissions which should associated with this Shared Identifier.
        :param str start: The ISO8061 UTC time at which this Access Policy should be valid from.
        """
        pulumi.set(__self__, "expiry", expiry)
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def expiry(self) -> str:
        """
        The ISO8061 UTC time at which this Access Policy should be valid until.
        """
        return pulumi.get(self, "expiry")

    @property
    @pulumi.getter
    def permissions(self) -> str:
        """
        The permissions which should associated with this Shared Identifier.
        """
        return pulumi.get(self, "permissions")

    @property
    @pulumi.getter
    def start(self) -> str:
        """
        The ISO8061 UTC time at which this Access Policy should be valid from.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class GetAccountBlobContainerSASPermissionsResult(dict):
    def __init__(__self__, *,
                 add: bool,
                 create: bool,
                 delete: bool,
                 list: bool,
                 read: bool,
                 write: bool):
        """
        :param bool add: Should Add permissions be enabled for this SAS?
        :param bool create: Should Create permissions be enabled for this SAS?
        :param bool delete: Should Delete permissions be enabled for this SAS?
        :param bool list: Should List permissions be enabled for this SAS?
        :param bool read: Should Read permissions be enabled for this SAS?
        :param bool write: Should Write permissions be enabled for this SAS?
        """
        pulumi.set(__self__, "add", add)
        pulumi.set(__self__, "create", create)
        pulumi.set(__self__, "delete", delete)
        pulumi.set(__self__, "list", list)
        pulumi.set(__self__, "read", read)
        pulumi.set(__self__, "write", write)

    @property
    @pulumi.getter
    def add(self) -> bool:
        """
        Should Add permissions be enabled for this SAS?
        """
        return pulumi.get(self, "add")

    @property
    @pulumi.getter
    def create(self) -> bool:
        """
        Should Create permissions be enabled for this SAS?
        """
        return pulumi.get(self, "create")

    @property
    @pulumi.getter
    def delete(self) -> bool:
        """
        Should Delete permissions be enabled for this SAS?
        """
        return pulumi.get(self, "delete")

    @property
    @pulumi.getter
    def list(self) -> bool:
        """
        Should List permissions be enabled for this SAS?
        """
        return pulumi.get(self, "list")

    @property
    @pulumi.getter
    def read(self) -> bool:
        """
        Should Read permissions be enabled for this SAS?
        """
        return pulumi.get(self, "read")

    @property
    @pulumi.getter
    def write(self) -> bool:
        """
        Should Write permissions be enabled for this SAS?
        """
        return pulumi.get(self, "write")


@pulumi.output_type
class GetAccountCustomDomainResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: Specifies the name of the Storage Account
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Storage Account
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetAccountSASPermissionsResult(dict):
    def __init__(__self__, *,
                 add: bool,
                 create: bool,
                 delete: bool,
                 list: bool,
                 process: bool,
                 read: bool,
                 update: bool,
                 write: bool):
        """
        :param bool add: Should Add permissions be enabled for this SAS?
        :param bool create: Should Create permissions be enabled for this SAS?
        :param bool delete: Should Delete permissions be enabled for this SAS?
        :param bool list: Should List permissions be enabled for this SAS?
        :param bool process: Should Process permissions be enabled for this SAS?
        :param bool read: Should Read permissions be enabled for this SAS?
        :param bool update: Should Update permissions be enabled for this SAS?
        :param bool write: Should Write permissions be enabled for this SAS?
        """
        pulumi.set(__self__, "add", add)
        pulumi.set(__self__, "create", create)
        pulumi.set(__self__, "delete", delete)
        pulumi.set(__self__, "list", list)
        pulumi.set(__self__, "process", process)
        pulumi.set(__self__, "read", read)
        pulumi.set(__self__, "update", update)
        pulumi.set(__self__, "write", write)

    @property
    @pulumi.getter
    def add(self) -> bool:
        """
        Should Add permissions be enabled for this SAS?
        """
        return pulumi.get(self, "add")

    @property
    @pulumi.getter
    def create(self) -> bool:
        """
        Should Create permissions be enabled for this SAS?
        """
        return pulumi.get(self, "create")

    @property
    @pulumi.getter
    def delete(self) -> bool:
        """
        Should Delete permissions be enabled for this SAS?
        """
        return pulumi.get(self, "delete")

    @property
    @pulumi.getter
    def list(self) -> bool:
        """
        Should List permissions be enabled for this SAS?
        """
        return pulumi.get(self, "list")

    @property
    @pulumi.getter
    def process(self) -> bool:
        """
        Should Process permissions be enabled for this SAS?
        """
        return pulumi.get(self, "process")

    @property
    @pulumi.getter
    def read(self) -> bool:
        """
        Should Read permissions be enabled for this SAS?
        """
        return pulumi.get(self, "read")

    @property
    @pulumi.getter
    def update(self) -> bool:
        """
        Should Update permissions be enabled for this SAS?
        """
        return pulumi.get(self, "update")

    @property
    @pulumi.getter
    def write(self) -> bool:
        """
        Should Write permissions be enabled for this SAS?
        """
        return pulumi.get(self, "write")


@pulumi.output_type
class GetAccountSASResourceTypesResult(dict):
    def __init__(__self__, *,
                 container: bool,
                 object: bool,
                 service: bool):
        """
        :param bool container: Should permission be granted to the container?
        :param bool object: Should permission be granted only to a specific object?
        :param bool service: Should permission be granted to the entire service?
        """
        pulumi.set(__self__, "container", container)
        pulumi.set(__self__, "object", object)
        pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def container(self) -> bool:
        """
        Should permission be granted to the container?
        """
        return pulumi.get(self, "container")

    @property
    @pulumi.getter
    def object(self) -> bool:
        """
        Should permission be granted only to a specific object?
        """
        return pulumi.get(self, "object")

    @property
    @pulumi.getter
    def service(self) -> bool:
        """
        Should permission be granted to the entire service?
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetAccountSASServicesResult(dict):
    def __init__(__self__, *,
                 blob: bool,
                 file: bool,
                 queue: bool,
                 table: bool):
        """
        :param bool blob: Should permission be granted to `blob` services within this storage account?
        :param bool file: Should permission be granted to `file` services within this storage account?
        :param bool queue: Should permission be granted to `queue` services within this storage account?
        :param bool table: Should permission be granted to `table` services within this storage account?
        """
        pulumi.set(__self__, "blob", blob)
        pulumi.set(__self__, "file", file)
        pulumi.set(__self__, "queue", queue)
        pulumi.set(__self__, "table", table)

    @property
    @pulumi.getter
    def blob(self) -> bool:
        """
        Should permission be granted to `blob` services within this storage account?
        """
        return pulumi.get(self, "blob")

    @property
    @pulumi.getter
    def file(self) -> bool:
        """
        Should permission be granted to `file` services within this storage account?
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def queue(self) -> bool:
        """
        Should permission be granted to `queue` services within this storage account?
        """
        return pulumi.get(self, "queue")

    @property
    @pulumi.getter
    def table(self) -> bool:
        """
        Should permission be granted to `table` services within this storage account?
        """
        return pulumi.get(self, "table")


@pulumi.output_type
class GetPolicyRuleResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetPolicyRuleActionResult'],
                 enabled: bool,
                 filters: Sequence['outputs.GetPolicyRuleFilterResult'],
                 name: str):
        """
        :param Sequence['GetPolicyRuleActionArgs'] actions: An `actions` block as documented below.
        :param bool enabled: Boolean to specify whether the rule is enabled.
        :param Sequence['GetPolicyRuleFilterArgs'] filters: A `filter` block as documented below.
        :param str name: The filter tag name used for tag based filtering for blob objects.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "filters", filters)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetPolicyRuleActionResult']:
        """
        An `actions` block as documented below.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Boolean to specify whether the rule is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def filters(self) -> Sequence['outputs.GetPolicyRuleFilterResult']:
        """
        A `filter` block as documented below.
        """
        return pulumi.get(self, "filters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The filter tag name used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetPolicyRuleActionResult(dict):
    def __init__(__self__, *,
                 base_blobs: Sequence['outputs.GetPolicyRuleActionBaseBlobResult'],
                 snapshots: Sequence['outputs.GetPolicyRuleActionSnapshotResult'],
                 versions: Sequence['outputs.GetPolicyRuleActionVersionResult']):
        """
        :param Sequence['GetPolicyRuleActionBaseBlobArgs'] base_blobs: A `base_blob` block as documented below.
        :param Sequence['GetPolicyRuleActionSnapshotArgs'] snapshots: A `snapshot` block as documented below.
        :param Sequence['GetPolicyRuleActionVersionArgs'] versions: A `version` block as documented below.
        """
        pulumi.set(__self__, "base_blobs", base_blobs)
        pulumi.set(__self__, "snapshots", snapshots)
        pulumi.set(__self__, "versions", versions)

    @property
    @pulumi.getter(name="baseBlobs")
    def base_blobs(self) -> Sequence['outputs.GetPolicyRuleActionBaseBlobResult']:
        """
        A `base_blob` block as documented below.
        """
        return pulumi.get(self, "base_blobs")

    @property
    @pulumi.getter
    def snapshots(self) -> Sequence['outputs.GetPolicyRuleActionSnapshotResult']:
        """
        A `snapshot` block as documented below.
        """
        return pulumi.get(self, "snapshots")

    @property
    @pulumi.getter
    def versions(self) -> Sequence['outputs.GetPolicyRuleActionVersionResult']:
        """
        A `version` block as documented below.
        """
        return pulumi.get(self, "versions")


@pulumi.output_type
class GetPolicyRuleActionBaseBlobResult(dict):
    def __init__(__self__, *,
                 delete_after_days_since_modification_greater_than: int,
                 tier_to_archive_after_days_since_modification_greater_than: int,
                 tier_to_cool_after_days_since_modification_greater_than: int):
        """
        :param int delete_after_days_since_modification_greater_than: The age in days after last modification to delete the blob.
        :param int tier_to_archive_after_days_since_modification_greater_than: The age in days after last modification to tier blobs to archive storage. Supports blob currently at Hot or Cool tier.
        :param int tier_to_cool_after_days_since_modification_greater_than: The age in days after last modification to tier blobs to cool storage. Supports blob currently at Hot tier.
        """
        pulumi.set(__self__, "delete_after_days_since_modification_greater_than", delete_after_days_since_modification_greater_than)
        pulumi.set(__self__, "tier_to_archive_after_days_since_modification_greater_than", tier_to_archive_after_days_since_modification_greater_than)
        pulumi.set(__self__, "tier_to_cool_after_days_since_modification_greater_than", tier_to_cool_after_days_since_modification_greater_than)

    @property
    @pulumi.getter(name="deleteAfterDaysSinceModificationGreaterThan")
    def delete_after_days_since_modification_greater_than(self) -> int:
        """
        The age in days after last modification to delete the blob.
        """
        return pulumi.get(self, "delete_after_days_since_modification_greater_than")

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceModificationGreaterThan")
    def tier_to_archive_after_days_since_modification_greater_than(self) -> int:
        """
        The age in days after last modification to tier blobs to archive storage. Supports blob currently at Hot or Cool tier.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_modification_greater_than")

    @property
    @pulumi.getter(name="tierToCoolAfterDaysSinceModificationGreaterThan")
    def tier_to_cool_after_days_since_modification_greater_than(self) -> int:
        """
        The age in days after last modification to tier blobs to cool storage. Supports blob currently at Hot tier.
        """
        return pulumi.get(self, "tier_to_cool_after_days_since_modification_greater_than")


@pulumi.output_type
class GetPolicyRuleActionSnapshotResult(dict):
    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: int,
                 change_tier_to_cool_after_days_since_creation: int,
                 delete_after_days_since_creation_greater_than: int):
        """
        :param int change_tier_to_archive_after_days_since_creation: The age in days after creation to tier blob version to archive storage.
        :param int change_tier_to_cool_after_days_since_creation: The age in days after creation to tier blob version to cool storage.
        :param int delete_after_days_since_creation_greater_than: The age in days after creation to delete the blob snapshot.
        """
        pulumi.set(__self__, "change_tier_to_archive_after_days_since_creation", change_tier_to_archive_after_days_since_creation)
        pulumi.set(__self__, "change_tier_to_cool_after_days_since_creation", change_tier_to_cool_after_days_since_creation)
        pulumi.set(__self__, "delete_after_days_since_creation_greater_than", delete_after_days_since_creation_greater_than)

    @property
    @pulumi.getter(name="changeTierToArchiveAfterDaysSinceCreation")
    def change_tier_to_archive_after_days_since_creation(self) -> int:
        """
        The age in days after creation to tier blob version to archive storage.
        """
        return pulumi.get(self, "change_tier_to_archive_after_days_since_creation")

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> int:
        """
        The age in days after creation to tier blob version to cool storage.
        """
        return pulumi.get(self, "change_tier_to_cool_after_days_since_creation")

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreationGreaterThan")
    def delete_after_days_since_creation_greater_than(self) -> int:
        """
        The age in days after creation to delete the blob snapshot.
        """
        return pulumi.get(self, "delete_after_days_since_creation_greater_than")


@pulumi.output_type
class GetPolicyRuleActionVersionResult(dict):
    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: int,
                 change_tier_to_cool_after_days_since_creation: int,
                 delete_after_days_since_creation: int):
        """
        :param int change_tier_to_archive_after_days_since_creation: The age in days after creation to tier blob version to archive storage.
        :param int change_tier_to_cool_after_days_since_creation: The age in days after creation to tier blob version to cool storage.
        :param int delete_after_days_since_creation: The age in days after creation to delete the blob version.
        """
        pulumi.set(__self__, "change_tier_to_archive_after_days_since_creation", change_tier_to_archive_after_days_since_creation)
        pulumi.set(__self__, "change_tier_to_cool_after_days_since_creation", change_tier_to_cool_after_days_since_creation)
        pulumi.set(__self__, "delete_after_days_since_creation", delete_after_days_since_creation)

    @property
    @pulumi.getter(name="changeTierToArchiveAfterDaysSinceCreation")
    def change_tier_to_archive_after_days_since_creation(self) -> int:
        """
        The age in days after creation to tier blob version to archive storage.
        """
        return pulumi.get(self, "change_tier_to_archive_after_days_since_creation")

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> int:
        """
        The age in days after creation to tier blob version to cool storage.
        """
        return pulumi.get(self, "change_tier_to_cool_after_days_since_creation")

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreation")
    def delete_after_days_since_creation(self) -> int:
        """
        The age in days after creation to delete the blob version.
        """
        return pulumi.get(self, "delete_after_days_since_creation")


@pulumi.output_type
class GetPolicyRuleFilterResult(dict):
    def __init__(__self__, *,
                 blob_types: Sequence[str],
                 match_blob_index_tags: Sequence['outputs.GetPolicyRuleFilterMatchBlobIndexTagResult'],
                 prefix_matches: Sequence[str]):
        """
        :param Sequence[str] blob_types: An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        :param Sequence['GetPolicyRuleFilterMatchBlobIndexTagArgs'] match_blob_index_tags: A `match_blob_index_tag` block as defined below. The block defines the blob index tag based filtering for blob objects.
               ---
        :param Sequence[str] prefix_matches: An array of strings for prefixes to be matched.
        """
        pulumi.set(__self__, "blob_types", blob_types)
        pulumi.set(__self__, "match_blob_index_tags", match_blob_index_tags)
        pulumi.set(__self__, "prefix_matches", prefix_matches)

    @property
    @pulumi.getter(name="blobTypes")
    def blob_types(self) -> Sequence[str]:
        """
        An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        """
        return pulumi.get(self, "blob_types")

    @property
    @pulumi.getter(name="matchBlobIndexTags")
    def match_blob_index_tags(self) -> Sequence['outputs.GetPolicyRuleFilterMatchBlobIndexTagResult']:
        """
        A `match_blob_index_tag` block as defined below. The block defines the blob index tag based filtering for blob objects.
        ---
        """
        return pulumi.get(self, "match_blob_index_tags")

    @property
    @pulumi.getter(name="prefixMatches")
    def prefix_matches(self) -> Sequence[str]:
        """
        An array of strings for prefixes to be matched.
        """
        return pulumi.get(self, "prefix_matches")


@pulumi.output_type
class GetPolicyRuleFilterMatchBlobIndexTagResult(dict):
    def __init__(__self__, *,
                 name: str,
                 operation: str,
                 value: str):
        """
        :param str name: The filter tag name used for tag based filtering for blob objects.
        :param str operation: The comparison operator which is used for object comparison and filtering. Possible value is `==`. Defaults to `==`.
        :param str value: The filter tag value used for tag based filtering for blob objects.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The filter tag name used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def operation(self) -> str:
        """
        The comparison operator which is used for object comparison and filtering. Possible value is `==`. Defaults to `==`.
        """
        return pulumi.get(self, "operation")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The filter tag value used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "value")


