# 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

__all__ = [
    'AccountAzureFilesAuthenticationArgs',
    'AccountAzureFilesAuthenticationActiveDirectoryArgs',
    'AccountBlobPropertiesArgs',
    'AccountBlobPropertiesContainerDeleteRetentionPolicyArgs',
    'AccountBlobPropertiesCorsRuleArgs',
    'AccountBlobPropertiesDeleteRetentionPolicyArgs',
    'AccountCustomDomainArgs',
    'AccountCustomerManagedKeyArgs',
    'AccountIdentityArgs',
    'AccountNetworkRulesArgs',
    'AccountNetworkRulesPrivateLinkAccessArgs',
    'AccountNetworkRulesPrivateLinkAccessRuleArgs',
    'AccountQueuePropertiesArgs',
    'AccountQueuePropertiesCorsRuleArgs',
    'AccountQueuePropertiesHourMetricsArgs',
    'AccountQueuePropertiesLoggingArgs',
    'AccountQueuePropertiesMinuteMetricsArgs',
    'AccountRoutingArgs',
    'AccountSharePropertiesArgs',
    'AccountSharePropertiesCorsRuleArgs',
    'AccountSharePropertiesRetentionPolicyArgs',
    'AccountSharePropertiesSmbArgs',
    'AccountStaticWebsiteArgs',
    'BlobInventoryPolicyRuleArgs',
    'BlobInventoryPolicyRuleFilterArgs',
    'DataLakeGen2FilesystemAceArgs',
    'DataLakeGen2PathAceArgs',
    'ManagementPolicyRuleArgs',
    'ManagementPolicyRuleActionsArgs',
    'ManagementPolicyRuleActionsBaseBlobArgs',
    'ManagementPolicyRuleActionsSnapshotArgs',
    'ManagementPolicyRuleActionsVersionArgs',
    'ManagementPolicyRuleFiltersArgs',
    'ManagementPolicyRuleFiltersMatchBlobIndexTagArgs',
    'ObjectReplicationRuleArgs',
    'ShareAclArgs',
    'ShareAclAccessPolicyArgs',
    'TableAclArgs',
    'TableAclAccessPolicyArgs',
    'GetAccountBlobContainerSASPermissionsArgs',
    'GetAccountSASPermissionsArgs',
    'GetAccountSASResourceTypesArgs',
    'GetAccountSASServicesArgs',
    'GetShareAclArgs',
    'GetShareAclAccessPolicyArgs',
]

@pulumi.input_type
class AccountAzureFilesAuthenticationArgs:
    def __init__(__self__, *,
                 directory_type: pulumi.Input[str],
                 active_directory: Optional[pulumi.Input['AccountAzureFilesAuthenticationActiveDirectoryArgs']] = None):
        """
        :param pulumi.Input[str] directory_type: Specifies the directory service used. Possible values are `AADDS` and `AD`.
        :param pulumi.Input['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) -> pulumi.Input[str]:
        """
        Specifies the directory service used. Possible values are `AADDS` and `AD`.
        """
        return pulumi.get(self, "directory_type")

    @directory_type.setter
    def directory_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "directory_type", value)

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

    @active_directory.setter
    def active_directory(self, value: Optional[pulumi.Input['AccountAzureFilesAuthenticationActiveDirectoryArgs']]):
        pulumi.set(self, "active_directory", value)


@pulumi.input_type
class AccountAzureFilesAuthenticationActiveDirectoryArgs:
    def __init__(__self__, *,
                 domain_guid: pulumi.Input[str],
                 domain_name: pulumi.Input[str],
                 domain_sid: pulumi.Input[str],
                 forest_name: pulumi.Input[str],
                 netbios_domain_name: pulumi.Input[str],
                 storage_sid: pulumi.Input[str]):
        """
        :param pulumi.Input[str] domain_guid: Specifies the domain GUID.
        :param pulumi.Input[str] domain_name: Specifies the primary domain that the AD DNS server is authoritative for.
        :param pulumi.Input[str] domain_sid: Specifies the security identifier (SID).
        :param pulumi.Input[str] forest_name: Specifies the Active Directory forest.
        :param pulumi.Input[str] netbios_domain_name: Specifies the NetBIOS domain name.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Specifies the domain GUID.
        """
        return pulumi.get(self, "domain_guid")

    @domain_guid.setter
    def domain_guid(self, value: pulumi.Input[str]):
        pulumi.set(self, "domain_guid", value)

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

    @domain_name.setter
    def domain_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "domain_name", value)

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

    @domain_sid.setter
    def domain_sid(self, value: pulumi.Input[str]):
        pulumi.set(self, "domain_sid", value)

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

    @forest_name.setter
    def forest_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "forest_name", value)

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

    @netbios_domain_name.setter
    def netbios_domain_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "netbios_domain_name", value)

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

    @storage_sid.setter
    def storage_sid(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_sid", value)


@pulumi.input_type
class AccountBlobPropertiesArgs:
    def __init__(__self__, *,
                 change_feed_enabled: Optional[pulumi.Input[bool]] = None,
                 container_delete_retention_policy: Optional[pulumi.Input['AccountBlobPropertiesContainerDeleteRetentionPolicyArgs']] = None,
                 cors_rules: Optional[pulumi.Input[Sequence[pulumi.Input['AccountBlobPropertiesCorsRuleArgs']]]] = None,
                 default_service_version: Optional[pulumi.Input[str]] = None,
                 delete_retention_policy: Optional[pulumi.Input['AccountBlobPropertiesDeleteRetentionPolicyArgs']] = None,
                 last_access_time_enabled: Optional[pulumi.Input[bool]] = None,
                 versioning_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] change_feed_enabled: Is the blob service properties for change feed events enabled? Default to `false`.
        :param pulumi.Input['AccountBlobPropertiesContainerDeleteRetentionPolicyArgs'] container_delete_retention_policy: A `container_delete_retention_policy` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['AccountBlobPropertiesCorsRuleArgs']]] cors_rules: A `cors_rule` block as defined below.
        :param pulumi.Input[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 pulumi.Input['AccountBlobPropertiesDeleteRetentionPolicyArgs'] delete_retention_policy: A `delete_retention_policy` block as defined below.
        :param pulumi.Input[bool] last_access_time_enabled: Is the last access time based tracking enabled? Default to `false`.
        :param pulumi.Input[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[pulumi.Input[bool]]:
        """
        Is the blob service properties for change feed events enabled? Default to `false`.
        """
        return pulumi.get(self, "change_feed_enabled")

    @change_feed_enabled.setter
    def change_feed_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "change_feed_enabled", value)

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

    @container_delete_retention_policy.setter
    def container_delete_retention_policy(self, value: Optional[pulumi.Input['AccountBlobPropertiesContainerDeleteRetentionPolicyArgs']]):
        pulumi.set(self, "container_delete_retention_policy", value)

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

    @cors_rules.setter
    def cors_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AccountBlobPropertiesCorsRuleArgs']]]]):
        pulumi.set(self, "cors_rules", value)

    @property
    @pulumi.getter(name="defaultServiceVersion")
    def default_service_version(self) -> Optional[pulumi.Input[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")

    @default_service_version.setter
    def default_service_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_service_version", value)

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

    @delete_retention_policy.setter
    def delete_retention_policy(self, value: Optional[pulumi.Input['AccountBlobPropertiesDeleteRetentionPolicyArgs']]):
        pulumi.set(self, "delete_retention_policy", value)

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

    @last_access_time_enabled.setter
    def last_access_time_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "last_access_time_enabled", value)

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

    @versioning_enabled.setter
    def versioning_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "versioning_enabled", value)


@pulumi.input_type
class AccountBlobPropertiesContainerDeleteRetentionPolicyArgs:
    def __init__(__self__, *,
                 days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[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")

    @days.setter
    def days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "days", value)


@pulumi.input_type
class AccountBlobPropertiesCorsRuleArgs:
    def __init__(__self__, *,
                 allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]],
                 exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 max_age_in_seconds: pulumi.Input[int]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_headers: A list of headers that are allowed to be a part of the cross-origin request.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: A list of HTTP methods that are allowed to be executed by the origin. Valid options are
               `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: A list of origin domains that will be allowed by CORS.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exposed_headers: A list of response headers that are exposed to CORS clients.
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        return pulumi.get(self, "allowed_headers")

    @allowed_headers.setter
    def allowed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_headers", value)

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of HTTP methods 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")

    @allowed_methods.setter
    def allowed_methods(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_methods", value)

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

    @allowed_origins.setter
    def allowed_origins(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_origins", value)

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

    @exposed_headers.setter
    def exposed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "exposed_headers", value)

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

    @max_age_in_seconds.setter
    def max_age_in_seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_age_in_seconds", value)


@pulumi.input_type
class AccountBlobPropertiesDeleteRetentionPolicyArgs:
    def __init__(__self__, *,
                 days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[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")

    @days.setter
    def days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "days", value)


@pulumi.input_type
class AccountCustomDomainArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 use_subdomain: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] name: The Custom Domain Name to use for the Storage Account, which will be validated by Azure.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Custom Domain Name to use for the Storage Account, which will be validated by Azure.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @use_subdomain.setter
    def use_subdomain(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_subdomain", value)


@pulumi.input_type
class AccountCustomerManagedKeyArgs:
    def __init__(__self__, *,
                 key_vault_key_id: pulumi.Input[str],
                 user_assigned_identity_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key_vault_key_id: The ID of the Key Vault Key, supplying a version-less key ID will enable auto-rotation of this key.
        :param pulumi.Input[str] user_assigned_identity_id: The ID of a user assigned identity.
        """
        pulumi.set(__self__, "key_vault_key_id", key_vault_key_id)
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="keyVaultKeyId")
    def key_vault_key_id(self) -> pulumi.Input[str]:
        """
        The ID of the Key Vault Key, supplying a version-less key ID will enable auto-rotation of this key.
        """
        return pulumi.get(self, "key_vault_key_id")

    @key_vault_key_id.setter
    def key_vault_key_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_vault_key_id", value)

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> pulumi.Input[str]:
        """
        The ID of a user assigned identity.
        """
        return pulumi.get(self, "user_assigned_identity_id")

    @user_assigned_identity_id.setter
    def user_assigned_identity_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_assigned_identity_id", value)


@pulumi.input_type
class AccountIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this Storage Account. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this Storage Account.
        :param pulumi.Input[str] principal_id: The Principal ID for the Service Principal associated with the Identity of this Storage Account.
        :param pulumi.Input[str] tenant_id: The Tenant ID for the Service Principal associated with the Identity of this Storage Account.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        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) -> pulumi.Input[str]:
        """
        Specifies the type of Managed Service Identity that should be configured on this Storage Account. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this Storage Account.
        """
        return pulumi.get(self, "identity_ids")

    @identity_ids.setter
    def identity_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "identity_ids", value)

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

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

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

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


@pulumi.input_type
class AccountNetworkRulesArgs:
    def __init__(__self__, *,
                 default_action: pulumi.Input[str],
                 bypasses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 private_link_accesses: Optional[pulumi.Input[Sequence[pulumi.Input['AccountNetworkRulesPrivateLinkAccessArgs']]]] = None,
                 virtual_network_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] default_action: Specifies the default action of allow or deny when no other rules match. Valid options are `Deny` or `Allow`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] bypasses: Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Valid options are
               any combination of `Logging`, `Metrics`, `AzureServices`, or `None`.
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input['AccountNetworkRulesPrivateLinkAccessArgs']]] private_link_accesses: One or More `private_link_access` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[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")

    @default_action.setter
    def default_action(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_action", value)

    @property
    @pulumi.getter
    def bypasses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @bypasses.setter
    def bypasses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "bypasses", value)

    @property
    @pulumi.getter(name="ipRules")
    def ip_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @ip_rules.setter
    def ip_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_rules", value)

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

    @private_link_accesses.setter
    def private_link_accesses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AccountNetworkRulesPrivateLinkAccessArgs']]]]):
        pulumi.set(self, "private_link_accesses", value)

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

    @virtual_network_subnet_ids.setter
    def virtual_network_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "virtual_network_subnet_ids", value)


@pulumi.input_type
class AccountNetworkRulesPrivateLinkAccessArgs:
    def __init__(__self__, *,
                 endpoint_resource_id: pulumi.Input[str],
                 endpoint_tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint_resource_id: The resource id of the resource access rule to be granted access.
        :param pulumi.Input[str] endpoint_tenant_id: The tenant id of the resource of the resource access rule to be granted access. 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) -> pulumi.Input[str]:
        """
        The resource id of the resource access rule to be granted access.
        """
        return pulumi.get(self, "endpoint_resource_id")

    @endpoint_resource_id.setter
    def endpoint_resource_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint_resource_id", value)

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

    @endpoint_tenant_id.setter
    def endpoint_tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint_tenant_id", value)


@pulumi.input_type
class AccountNetworkRulesPrivateLinkAccessRuleArgs:
    def __init__(__self__, *,
                 endpoint_resource_id: pulumi.Input[str],
                 endpoint_tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint_resource_id: The resource id of the resource access rule to be granted access.
        :param pulumi.Input[str] endpoint_tenant_id: The tenant id of the resource of the resource access rule to be granted access. 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) -> pulumi.Input[str]:
        """
        The resource id of the resource access rule to be granted access.
        """
        return pulumi.get(self, "endpoint_resource_id")

    @endpoint_resource_id.setter
    def endpoint_resource_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint_resource_id", value)

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

    @endpoint_tenant_id.setter
    def endpoint_tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint_tenant_id", value)


@pulumi.input_type
class AccountQueuePropertiesArgs:
    def __init__(__self__, *,
                 cors_rules: Optional[pulumi.Input[Sequence[pulumi.Input['AccountQueuePropertiesCorsRuleArgs']]]] = None,
                 hour_metrics: Optional[pulumi.Input['AccountQueuePropertiesHourMetricsArgs']] = None,
                 logging: Optional[pulumi.Input['AccountQueuePropertiesLoggingArgs']] = None,
                 minute_metrics: Optional[pulumi.Input['AccountQueuePropertiesMinuteMetricsArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AccountQueuePropertiesCorsRuleArgs']]] cors_rules: A `cors_rule` block as defined above.
        :param pulumi.Input['AccountQueuePropertiesHourMetricsArgs'] hour_metrics: A `hour_metrics` block as defined below.
        :param pulumi.Input['AccountQueuePropertiesLoggingArgs'] logging: A `logging` block as defined below.
        :param pulumi.Input['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[pulumi.Input[Sequence[pulumi.Input['AccountQueuePropertiesCorsRuleArgs']]]]:
        """
        A `cors_rule` block as defined above.
        """
        return pulumi.get(self, "cors_rules")

    @cors_rules.setter
    def cors_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AccountQueuePropertiesCorsRuleArgs']]]]):
        pulumi.set(self, "cors_rules", value)

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

    @hour_metrics.setter
    def hour_metrics(self, value: Optional[pulumi.Input['AccountQueuePropertiesHourMetricsArgs']]):
        pulumi.set(self, "hour_metrics", value)

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

    @logging.setter
    def logging(self, value: Optional[pulumi.Input['AccountQueuePropertiesLoggingArgs']]):
        pulumi.set(self, "logging", value)

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

    @minute_metrics.setter
    def minute_metrics(self, value: Optional[pulumi.Input['AccountQueuePropertiesMinuteMetricsArgs']]):
        pulumi.set(self, "minute_metrics", value)


@pulumi.input_type
class AccountQueuePropertiesCorsRuleArgs:
    def __init__(__self__, *,
                 allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]],
                 exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 max_age_in_seconds: pulumi.Input[int]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_headers: A list of headers that are allowed to be a part of the cross-origin request.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: A list of HTTP methods that are allowed to be executed by the origin. Valid options are
               `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: A list of origin domains that will be allowed by CORS.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exposed_headers: A list of response headers that are exposed to CORS clients.
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        return pulumi.get(self, "allowed_headers")

    @allowed_headers.setter
    def allowed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_headers", value)

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of HTTP methods 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")

    @allowed_methods.setter
    def allowed_methods(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_methods", value)

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

    @allowed_origins.setter
    def allowed_origins(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_origins", value)

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

    @exposed_headers.setter
    def exposed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "exposed_headers", value)

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

    @max_age_in_seconds.setter
    def max_age_in_seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_age_in_seconds", value)


@pulumi.input_type
class AccountQueuePropertiesHourMetricsArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 version: pulumi.Input[str],
                 include_apis: Optional[pulumi.Input[bool]] = None,
                 retention_policy_days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enabled: Indicates whether hour metrics are enabled for the Queue service. Changing this forces a new resource.
        :param pulumi.Input[str] version: The version of storage analytics to configure. Changing this forces a new resource.
        :param pulumi.Input[bool] include_apis: Indicates whether metrics should generate summary statistics for called API operations.
        :param pulumi.Input[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) -> pulumi.Input[bool]:
        """
        Indicates whether hour metrics are enabled for the Queue service. Changing this forces a new resource.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

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

    @version.setter
    def version(self, value: pulumi.Input[str]):
        pulumi.set(self, "version", value)

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

    @include_apis.setter
    def include_apis(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_apis", value)

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

    @retention_policy_days.setter
    def retention_policy_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention_policy_days", value)


@pulumi.input_type
class AccountQueuePropertiesLoggingArgs:
    def __init__(__self__, *,
                 delete: pulumi.Input[bool],
                 read: pulumi.Input[bool],
                 version: pulumi.Input[str],
                 write: pulumi.Input[bool],
                 retention_policy_days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] delete: Indicates whether all delete requests should be logged. Changing this forces a new resource.
        :param pulumi.Input[bool] read: Indicates whether all read requests should be logged. Changing this forces a new resource.
        :param pulumi.Input[str] version: The version of storage analytics to configure. Changing this forces a new resource.
        :param pulumi.Input[bool] write: Indicates whether all write requests should be logged. Changing this forces a new resource.
        :param pulumi.Input[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) -> pulumi.Input[bool]:
        """
        Indicates whether all delete requests should be logged. Changing this forces a new resource.
        """
        return pulumi.get(self, "delete")

    @delete.setter
    def delete(self, value: pulumi.Input[bool]):
        pulumi.set(self, "delete", value)

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

    @read.setter
    def read(self, value: pulumi.Input[bool]):
        pulumi.set(self, "read", value)

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

    @version.setter
    def version(self, value: pulumi.Input[str]):
        pulumi.set(self, "version", value)

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

    @write.setter
    def write(self, value: pulumi.Input[bool]):
        pulumi.set(self, "write", value)

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

    @retention_policy_days.setter
    def retention_policy_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention_policy_days", value)


@pulumi.input_type
class AccountQueuePropertiesMinuteMetricsArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 version: pulumi.Input[str],
                 include_apis: Optional[pulumi.Input[bool]] = None,
                 retention_policy_days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enabled: Indicates whether minute metrics are enabled for the Queue service. Changing this forces a new resource.
        :param pulumi.Input[str] version: The version of storage analytics to configure. Changing this forces a new resource.
        :param pulumi.Input[bool] include_apis: Indicates whether metrics should generate summary statistics for called API operations.
        :param pulumi.Input[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) -> pulumi.Input[bool]:
        """
        Indicates whether minute metrics are enabled for the Queue service. Changing this forces a new resource.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

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

    @version.setter
    def version(self, value: pulumi.Input[str]):
        pulumi.set(self, "version", value)

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

    @include_apis.setter
    def include_apis(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_apis", value)

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

    @retention_policy_days.setter
    def retention_policy_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention_policy_days", value)


@pulumi.input_type
class AccountRoutingArgs:
    def __init__(__self__, *,
                 choice: Optional[pulumi.Input[str]] = None,
                 publish_internet_endpoints: Optional[pulumi.Input[bool]] = None,
                 publish_microsoft_endpoints: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] choice: Specifies the kind of network routing opted by the user. Possible values are `InternetRouting` and `MicrosoftRouting`. Defaults to `MicrosoftRouting`.
        :param pulumi.Input[bool] publish_internet_endpoints: Should internet routing storage endpoints be published? Defaults to `false`.
        :param pulumi.Input[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[pulumi.Input[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")

    @choice.setter
    def choice(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "choice", value)

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

    @publish_internet_endpoints.setter
    def publish_internet_endpoints(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "publish_internet_endpoints", value)

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

    @publish_microsoft_endpoints.setter
    def publish_microsoft_endpoints(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "publish_microsoft_endpoints", value)


@pulumi.input_type
class AccountSharePropertiesArgs:
    def __init__(__self__, *,
                 cors_rules: Optional[pulumi.Input[Sequence[pulumi.Input['AccountSharePropertiesCorsRuleArgs']]]] = None,
                 retention_policy: Optional[pulumi.Input['AccountSharePropertiesRetentionPolicyArgs']] = None,
                 smb: Optional[pulumi.Input['AccountSharePropertiesSmbArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AccountSharePropertiesCorsRuleArgs']]] cors_rules: A `cors_rule` block as defined below.
        :param pulumi.Input['AccountSharePropertiesRetentionPolicyArgs'] retention_policy: A `retention_policy` block as defined below.
        :param pulumi.Input['AccountSharePropertiesSmbArgs'] smb: A `smb` block as defined below.
        """
        if cors_rules is not None:
            pulumi.set(__self__, "cors_rules", cors_rules)
        if retention_policy is not None:
            pulumi.set(__self__, "retention_policy", retention_policy)
        if smb is not None:
            pulumi.set(__self__, "smb", smb)

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

    @cors_rules.setter
    def cors_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AccountSharePropertiesCorsRuleArgs']]]]):
        pulumi.set(self, "cors_rules", value)

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> Optional[pulumi.Input['AccountSharePropertiesRetentionPolicyArgs']]:
        """
        A `retention_policy` block as defined below.
        """
        return pulumi.get(self, "retention_policy")

    @retention_policy.setter
    def retention_policy(self, value: Optional[pulumi.Input['AccountSharePropertiesRetentionPolicyArgs']]):
        pulumi.set(self, "retention_policy", value)

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

    @smb.setter
    def smb(self, value: Optional[pulumi.Input['AccountSharePropertiesSmbArgs']]):
        pulumi.set(self, "smb", value)


@pulumi.input_type
class AccountSharePropertiesCorsRuleArgs:
    def __init__(__self__, *,
                 allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]],
                 allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]],
                 exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]],
                 max_age_in_seconds: pulumi.Input[int]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_headers: A list of headers that are allowed to be a part of the cross-origin request.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: A list of HTTP methods that are allowed to be executed by the origin. Valid options are
               `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS`, `PUT` or `PATCH`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: A list of origin domains that will be allowed by CORS.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exposed_headers: A list of response headers that are exposed to CORS clients.
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        return pulumi.get(self, "allowed_headers")

    @allowed_headers.setter
    def allowed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_headers", value)

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of HTTP methods 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")

    @allowed_methods.setter
    def allowed_methods(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_methods", value)

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

    @allowed_origins.setter
    def allowed_origins(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "allowed_origins", value)

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

    @exposed_headers.setter
    def exposed_headers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "exposed_headers", value)

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

    @max_age_in_seconds.setter
    def max_age_in_seconds(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_age_in_seconds", value)


@pulumi.input_type
class AccountSharePropertiesRetentionPolicyArgs:
    def __init__(__self__, *,
                 days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] days: Specifies the number of days that the `storage.Share` 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[pulumi.Input[int]]:
        """
        Specifies the number of days that the `storage.Share` should be retained, between `1` and `365` days. Defaults to `7`.
        """
        return pulumi.get(self, "days")

    @days.setter
    def days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "days", value)


@pulumi.input_type
class AccountSharePropertiesSmbArgs:
    def __init__(__self__, *,
                 authentication_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 channel_encryption_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kerberos_ticket_encryption_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] authentication_types: A set of SMB authentication methods. Possible values are `NTLMv2`, and `Kerberos`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] channel_encryption_types: A set of SMB channel encryption. Possible values are `AES-128-CCM`, `AES-128-GCM`, and `AES-256-GCM`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] kerberos_ticket_encryption_types: A set of Kerberos ticket encryption. Possible values are `RC4-HMAC`, and `AES-256`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] versions: A set of SMB protocol versions. Possible values are `SMB2.1`, `SMB3.0`, and `SMB3.1.1`.
        """
        if authentication_types is not None:
            pulumi.set(__self__, "authentication_types", authentication_types)
        if channel_encryption_types is not None:
            pulumi.set(__self__, "channel_encryption_types", channel_encryption_types)
        if kerberos_ticket_encryption_types is not None:
            pulumi.set(__self__, "kerberos_ticket_encryption_types", kerberos_ticket_encryption_types)
        if versions is not None:
            pulumi.set(__self__, "versions", versions)

    @property
    @pulumi.getter(name="authenticationTypes")
    def authentication_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A set of SMB authentication methods. Possible values are `NTLMv2`, and `Kerberos`.
        """
        return pulumi.get(self, "authentication_types")

    @authentication_types.setter
    def authentication_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "authentication_types", value)

    @property
    @pulumi.getter(name="channelEncryptionTypes")
    def channel_encryption_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A set of SMB channel encryption. Possible values are `AES-128-CCM`, `AES-128-GCM`, and `AES-256-GCM`.
        """
        return pulumi.get(self, "channel_encryption_types")

    @channel_encryption_types.setter
    def channel_encryption_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "channel_encryption_types", value)

    @property
    @pulumi.getter(name="kerberosTicketEncryptionTypes")
    def kerberos_ticket_encryption_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A set of Kerberos ticket encryption. Possible values are `RC4-HMAC`, and `AES-256`.
        """
        return pulumi.get(self, "kerberos_ticket_encryption_types")

    @kerberos_ticket_encryption_types.setter
    def kerberos_ticket_encryption_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "kerberos_ticket_encryption_types", value)

    @property
    @pulumi.getter
    def versions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A set of SMB protocol versions. Possible values are `SMB2.1`, `SMB3.0`, and `SMB3.1.1`.
        """
        return pulumi.get(self, "versions")

    @versions.setter
    def versions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "versions", value)


@pulumi.input_type
class AccountStaticWebsiteArgs:
    def __init__(__self__, *,
                 error404_document: Optional[pulumi.Input[str]] = None,
                 index_document: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")

    @error404_document.setter
    def error404_document(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "error404_document", value)

    @property
    @pulumi.getter(name="indexDocument")
    def index_document(self) -> Optional[pulumi.Input[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")

    @index_document.setter
    def index_document(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index_document", value)


@pulumi.input_type
class BlobInventoryPolicyRuleArgs:
    def __init__(__self__, *,
                 format: pulumi.Input[str],
                 name: pulumi.Input[str],
                 schedule: pulumi.Input[str],
                 schema_fields: pulumi.Input[Sequence[pulumi.Input[str]]],
                 scope: pulumi.Input[str],
                 storage_container_name: pulumi.Input[str],
                 filter: Optional[pulumi.Input['BlobInventoryPolicyRuleFilterArgs']] = None):
        """
        :param pulumi.Input[str] format: The format of the inventory files. Possible values are `Csv` and `Parquet`.
        :param pulumi.Input[str] name: The name which should be used for this Blob Inventory Policy Rule.
        :param pulumi.Input[str] schedule: The inventory schedule applied by this rule. Possible values are `Daily` and `Weekly`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] schema_fields: A list of fields to be included in the inventory. See the [Azure API reference](https://docs.microsoft.com/rest/api/storagerp/blob-inventory-policies/create-or-update#blobinventorypolicydefinition) for all the supported fields.
        :param pulumi.Input[str] scope: The scope of the inventory for this rule. Possible values are `Blob` and `Container`.
        :param pulumi.Input[str] storage_container_name: The storage container name to store the blob inventory files for this rule.
        :param pulumi.Input['BlobInventoryPolicyRuleFilterArgs'] filter: A `filter` block as defined above. Can only be set when the `scope` is `Blob`.
        """
        pulumi.set(__self__, "format", format)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schedule", schedule)
        pulumi.set(__self__, "schema_fields", schema_fields)
        pulumi.set(__self__, "scope", scope)
        pulumi.set(__self__, "storage_container_name", storage_container_name)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)

    @property
    @pulumi.getter
    def format(self) -> pulumi.Input[str]:
        """
        The format of the inventory files. Possible values are `Csv` and `Parquet`.
        """
        return pulumi.get(self, "format")

    @format.setter
    def format(self, value: pulumi.Input[str]):
        pulumi.set(self, "format", value)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def schedule(self) -> pulumi.Input[str]:
        """
        The inventory schedule applied by this rule. Possible values are `Daily` and `Weekly`.
        """
        return pulumi.get(self, "schedule")

    @schedule.setter
    def schedule(self, value: pulumi.Input[str]):
        pulumi.set(self, "schedule", value)

    @property
    @pulumi.getter(name="schemaFields")
    def schema_fields(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list of fields to be included in the inventory. See the [Azure API reference](https://docs.microsoft.com/rest/api/storagerp/blob-inventory-policies/create-or-update#blobinventorypolicydefinition) for all the supported fields.
        """
        return pulumi.get(self, "schema_fields")

    @schema_fields.setter
    def schema_fields(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "schema_fields", value)

    @property
    @pulumi.getter
    def scope(self) -> pulumi.Input[str]:
        """
        The scope of the inventory for this rule. Possible values are `Blob` and `Container`.
        """
        return pulumi.get(self, "scope")

    @scope.setter
    def scope(self, value: pulumi.Input[str]):
        pulumi.set(self, "scope", value)

    @property
    @pulumi.getter(name="storageContainerName")
    def storage_container_name(self) -> pulumi.Input[str]:
        """
        The storage container name to store the blob inventory files for this rule.
        """
        return pulumi.get(self, "storage_container_name")

    @storage_container_name.setter
    def storage_container_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_container_name", value)

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['BlobInventoryPolicyRuleFilterArgs']]:
        """
        A `filter` block as defined above. Can only be set when the `scope` is `Blob`.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: Optional[pulumi.Input['BlobInventoryPolicyRuleFilterArgs']]):
        pulumi.set(self, "filter", value)


@pulumi.input_type
class BlobInventoryPolicyRuleFilterArgs:
    def __init__(__self__, *,
                 blob_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                 include_blob_versions: Optional[pulumi.Input[bool]] = None,
                 include_snapshots: Optional[pulumi.Input[bool]] = None,
                 prefix_matches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[bool] include_blob_versions: Includes blob versions in blob inventory or not? Defaults to `false`.
        :param pulumi.Input[bool] include_snapshots: Includes blob snapshots in blob inventory or not? Defaults to `false`.
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[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")

    @blob_types.setter
    def blob_types(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "blob_types", value)

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

    @include_blob_versions.setter
    def include_blob_versions(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_blob_versions", value)

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

    @include_snapshots.setter
    def include_snapshots(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_snapshots", value)

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

    @prefix_matches.setter
    def prefix_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "prefix_matches", value)


@pulumi.input_type
class DataLakeGen2FilesystemAceArgs:
    def __init__(__self__, *,
                 permissions: pulumi.Input[str],
                 type: pulumi.Input[str],
                 id: Optional[pulumi.Input[str]] = None,
                 scope: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] permissions: Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        :param pulumi.Input[str] type: Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @permissions.setter
    def permissions(self, value: pulumi.Input[str]):
        pulumi.set(self, "permissions", value)

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

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[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")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)

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

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scope", value)


@pulumi.input_type
class DataLakeGen2PathAceArgs:
    def __init__(__self__, *,
                 permissions: pulumi.Input[str],
                 type: pulumi.Input[str],
                 id: Optional[pulumi.Input[str]] = None,
                 scope: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] permissions: Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.
        :param pulumi.Input[str] type: Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @permissions.setter
    def permissions(self, value: pulumi.Input[str]):
        pulumi.set(self, "permissions", value)

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

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[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")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)

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

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scope", value)


@pulumi.input_type
class ManagementPolicyRuleArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input['ManagementPolicyRuleActionsArgs'],
                 enabled: pulumi.Input[bool],
                 name: pulumi.Input[str],
                 filters: Optional[pulumi.Input['ManagementPolicyRuleFiltersArgs']] = None):
        """
        :param pulumi.Input['ManagementPolicyRuleActionsArgs'] actions: An `actions` block as documented below.
        :param pulumi.Input[bool] enabled: Boolean to specify whether the rule is enabled.
        :param pulumi.Input[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 pulumi.Input['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) -> pulumi.Input['ManagementPolicyRuleActionsArgs']:
        """
        An `actions` block as documented below.
        """
        return pulumi.get(self, "actions")

    @actions.setter
    def actions(self, value: pulumi.Input['ManagementPolicyRuleActionsArgs']):
        pulumi.set(self, "actions", value)

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

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[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")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @filters.setter
    def filters(self, value: Optional[pulumi.Input['ManagementPolicyRuleFiltersArgs']]):
        pulumi.set(self, "filters", value)


@pulumi.input_type
class ManagementPolicyRuleActionsArgs:
    def __init__(__self__, *,
                 base_blob: Optional[pulumi.Input['ManagementPolicyRuleActionsBaseBlobArgs']] = None,
                 snapshot: Optional[pulumi.Input['ManagementPolicyRuleActionsSnapshotArgs']] = None,
                 version: Optional[pulumi.Input['ManagementPolicyRuleActionsVersionArgs']] = None):
        """
        :param pulumi.Input['ManagementPolicyRuleActionsBaseBlobArgs'] base_blob: A `base_blob` block as documented below.
        :param pulumi.Input['ManagementPolicyRuleActionsSnapshotArgs'] snapshot: A `snapshot` block as documented below.
        :param pulumi.Input['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[pulumi.Input['ManagementPolicyRuleActionsBaseBlobArgs']]:
        """
        A `base_blob` block as documented below.
        """
        return pulumi.get(self, "base_blob")

    @base_blob.setter
    def base_blob(self, value: Optional[pulumi.Input['ManagementPolicyRuleActionsBaseBlobArgs']]):
        pulumi.set(self, "base_blob", value)

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

    @snapshot.setter
    def snapshot(self, value: Optional[pulumi.Input['ManagementPolicyRuleActionsSnapshotArgs']]):
        pulumi.set(self, "snapshot", value)

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

    @version.setter
    def version(self, value: Optional[pulumi.Input['ManagementPolicyRuleActionsVersionArgs']]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class ManagementPolicyRuleActionsBaseBlobArgs:
    def __init__(__self__, *,
                 delete_after_days_since_last_access_time_greater_than: Optional[pulumi.Input[int]] = None,
                 delete_after_days_since_modification_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_archive_after_days_since_last_access_time_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_archive_after_days_since_modification_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cool_after_days_since_last_access_time_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cool_after_days_since_modification_greater_than: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] delete_after_days_since_last_access_time_greater_than: The age in days after last access time to delete the blob. Must be between `0` and `99999`.
        :param pulumi.Input[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 pulumi.Input[int] tier_to_archive_after_days_since_last_access_time_greater_than: The age in days after last access time to tier blobs to archive storage. Supports blob currently at Hot or Cool tier. Must be between `0 and `99999`.
        :param pulumi.Input[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 pulumi.Input[int] tier_to_cool_after_days_since_last_access_time_greater_than: The age in days after last access time to tier blobs to cool storage. Supports blob currently at Hot tier. Must be between `0` and `99999`.
        :param pulumi.Input[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_last_access_time_greater_than is not None:
            pulumi.set(__self__, "delete_after_days_since_last_access_time_greater_than", delete_after_days_since_last_access_time_greater_than)
        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_last_access_time_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_last_access_time_greater_than", tier_to_archive_after_days_since_last_access_time_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_last_access_time_greater_than is not None:
            pulumi.set(__self__, "tier_to_cool_after_days_since_last_access_time_greater_than", tier_to_cool_after_days_since_last_access_time_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="deleteAfterDaysSinceLastAccessTimeGreaterThan")
    def delete_after_days_since_last_access_time_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last access time to delete the blob. Must be between `0` and `99999`.
        """
        return pulumi.get(self, "delete_after_days_since_last_access_time_greater_than")

    @delete_after_days_since_last_access_time_greater_than.setter
    def delete_after_days_since_last_access_time_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delete_after_days_since_last_access_time_greater_than", value)

    @property
    @pulumi.getter(name="deleteAfterDaysSinceModificationGreaterThan")
    def delete_after_days_since_modification_greater_than(self) -> Optional[pulumi.Input[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")

    @delete_after_days_since_modification_greater_than.setter
    def delete_after_days_since_modification_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delete_after_days_since_modification_greater_than", value)

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceLastAccessTimeGreaterThan")
    def tier_to_archive_after_days_since_last_access_time_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last access time 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_last_access_time_greater_than")

    @tier_to_archive_after_days_since_last_access_time_greater_than.setter
    def tier_to_archive_after_days_since_last_access_time_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_archive_after_days_since_last_access_time_greater_than", value)

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceModificationGreaterThan")
    def tier_to_archive_after_days_since_modification_greater_than(self) -> Optional[pulumi.Input[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")

    @tier_to_archive_after_days_since_modification_greater_than.setter
    def tier_to_archive_after_days_since_modification_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_archive_after_days_since_modification_greater_than", value)

    @property
    @pulumi.getter(name="tierToCoolAfterDaysSinceLastAccessTimeGreaterThan")
    def tier_to_cool_after_days_since_last_access_time_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last access time 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_last_access_time_greater_than")

    @tier_to_cool_after_days_since_last_access_time_greater_than.setter
    def tier_to_cool_after_days_since_last_access_time_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_cool_after_days_since_last_access_time_greater_than", value)

    @property
    @pulumi.getter(name="tierToCoolAfterDaysSinceModificationGreaterThan")
    def tier_to_cool_after_days_since_modification_greater_than(self) -> Optional[pulumi.Input[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")

    @tier_to_cool_after_days_since_modification_greater_than.setter
    def tier_to_cool_after_days_since_modification_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_cool_after_days_since_modification_greater_than", value)


@pulumi.input_type
class ManagementPolicyRuleActionsSnapshotArgs:
    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: Optional[pulumi.Input[int]] = None,
                 change_tier_to_cool_after_days_since_creation: Optional[pulumi.Input[int]] = None,
                 delete_after_days_since_creation_greater_than: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")

    @change_tier_to_archive_after_days_since_creation.setter
    def change_tier_to_archive_after_days_since_creation(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "change_tier_to_archive_after_days_since_creation", value)

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> Optional[pulumi.Input[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")

    @change_tier_to_cool_after_days_since_creation.setter
    def change_tier_to_cool_after_days_since_creation(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "change_tier_to_cool_after_days_since_creation", value)

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreationGreaterThan")
    def delete_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[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")

    @delete_after_days_since_creation_greater_than.setter
    def delete_after_days_since_creation_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delete_after_days_since_creation_greater_than", value)


@pulumi.input_type
class ManagementPolicyRuleActionsVersionArgs:
    def __init__(__self__, *,
                 change_tier_to_archive_after_days_since_creation: Optional[pulumi.Input[int]] = None,
                 change_tier_to_cool_after_days_since_creation: Optional[pulumi.Input[int]] = None,
                 delete_after_days_since_creation: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")

    @change_tier_to_archive_after_days_since_creation.setter
    def change_tier_to_archive_after_days_since_creation(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "change_tier_to_archive_after_days_since_creation", value)

    @property
    @pulumi.getter(name="changeTierToCoolAfterDaysSinceCreation")
    def change_tier_to_cool_after_days_since_creation(self) -> Optional[pulumi.Input[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")

    @change_tier_to_cool_after_days_since_creation.setter
    def change_tier_to_cool_after_days_since_creation(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "change_tier_to_cool_after_days_since_creation", value)

    @property
    @pulumi.getter(name="deleteAfterDaysSinceCreation")
    def delete_after_days_since_creation(self) -> Optional[pulumi.Input[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")

    @delete_after_days_since_creation.setter
    def delete_after_days_since_creation(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delete_after_days_since_creation", value)


@pulumi.input_type
class ManagementPolicyRuleFiltersArgs:
    def __init__(__self__, *,
                 blob_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                 match_blob_index_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ManagementPolicyRuleFiltersMatchBlobIndexTagArgs']]]] = None,
                 prefix_matches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] blob_types: An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        :param pulumi.Input[Sequence[pulumi.Input['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 pulumi.Input[Sequence[pulumi.Input[str]]] prefix_matches: An array of strings for prefixes to be matched.
        """
        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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        """
        return pulumi.get(self, "blob_types")

    @blob_types.setter
    def blob_types(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "blob_types", value)

    @property
    @pulumi.getter(name="matchBlobIndexTags")
    def match_blob_index_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ManagementPolicyRuleFiltersMatchBlobIndexTagArgs']]]]:
        """
        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")

    @match_blob_index_tags.setter
    def match_blob_index_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ManagementPolicyRuleFiltersMatchBlobIndexTagArgs']]]]):
        pulumi.set(self, "match_blob_index_tags", value)

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

    @prefix_matches.setter
    def prefix_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "prefix_matches", value)


@pulumi.input_type
class ManagementPolicyRuleFiltersMatchBlobIndexTagArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str],
                 operation: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The filter tag name used for tag based filtering for blob objects.
        :param pulumi.Input[str] value: The filter tag value used for tag based filtering for blob objects.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The filter tag name used for tag based filtering for blob objects.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)

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

    @operation.setter
    def operation(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "operation", value)


@pulumi.input_type
class ObjectReplicationRuleArgs:
    def __init__(__self__, *,
                 destination_container_name: pulumi.Input[str],
                 source_container_name: pulumi.Input[str],
                 copy_blobs_created_after: Optional[pulumi.Input[str]] = None,
                 filter_out_blobs_with_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] destination_container_name: The destination storage container name. Changing this forces a new Storage Object Replication to be created.
        :param pulumi.Input[str] source_container_name: The source storage container name. Changing this forces a new Storage Object Replication to be created.
        :param pulumi.Input[str] copy_blobs_created_after: The time after which the Block Blobs created will be copies to the destination. Possible values are `OnlyNewObjects`, `Everything` and time in RFC3339 format: `2006-01-02T15:04:00Z`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] filter_out_blobs_with_prefixes: Specifies a list of filters prefixes, the blobs whose names begin with which will be replicated.
        """
        pulumi.set(__self__, "destination_container_name", destination_container_name)
        pulumi.set(__self__, "source_container_name", source_container_name)
        if copy_blobs_created_after is not None:
            pulumi.set(__self__, "copy_blobs_created_after", copy_blobs_created_after)
        if filter_out_blobs_with_prefixes is not None:
            pulumi.set(__self__, "filter_out_blobs_with_prefixes", filter_out_blobs_with_prefixes)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="destinationContainerName")
    def destination_container_name(self) -> pulumi.Input[str]:
        """
        The destination storage container name. Changing this forces a new Storage Object Replication to be created.
        """
        return pulumi.get(self, "destination_container_name")

    @destination_container_name.setter
    def destination_container_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "destination_container_name", value)

    @property
    @pulumi.getter(name="sourceContainerName")
    def source_container_name(self) -> pulumi.Input[str]:
        """
        The source storage container name. Changing this forces a new Storage Object Replication to be created.
        """
        return pulumi.get(self, "source_container_name")

    @source_container_name.setter
    def source_container_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_container_name", value)

    @property
    @pulumi.getter(name="copyBlobsCreatedAfter")
    def copy_blobs_created_after(self) -> Optional[pulumi.Input[str]]:
        """
        The time after which the Block Blobs created will be copies to the destination. Possible values are `OnlyNewObjects`, `Everything` and time in RFC3339 format: `2006-01-02T15:04:00Z`.
        """
        return pulumi.get(self, "copy_blobs_created_after")

    @copy_blobs_created_after.setter
    def copy_blobs_created_after(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "copy_blobs_created_after", value)

    @property
    @pulumi.getter(name="filterOutBlobsWithPrefixes")
    def filter_out_blobs_with_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of filters prefixes, the blobs whose names begin with which will be replicated.
        """
        return pulumi.get(self, "filter_out_blobs_with_prefixes")

    @filter_out_blobs_with_prefixes.setter
    def filter_out_blobs_with_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "filter_out_blobs_with_prefixes", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class ShareAclArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 access_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ShareAclAccessPolicyArgs']]]] = None):
        """
        :param pulumi.Input[str] id: The ID which should be used for this Shared Identifier.
        :param pulumi.Input[Sequence[pulumi.Input['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) -> pulumi.Input[str]:
        """
        The ID which should be used for this Shared Identifier.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @access_policies.setter
    def access_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ShareAclAccessPolicyArgs']]]]):
        pulumi.set(self, "access_policies", value)


@pulumi.input_type
class ShareAclAccessPolicyArgs:
    def __init__(__self__, *,
                 permissions: pulumi.Input[str],
                 expiry: Optional[pulumi.Input[str]] = None,
                 start: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[str] expiry: The time at which this Access Policy should be valid until, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        :param pulumi.Input[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) -> pulumi.Input[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")

    @permissions.setter
    def permissions(self, value: pulumi.Input[str]):
        pulumi.set(self, "permissions", value)

    @property
    @pulumi.getter
    def expiry(self) -> Optional[pulumi.Input[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")

    @expiry.setter
    def expiry(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "expiry", value)

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[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")

    @start.setter
    def start(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start", value)


@pulumi.input_type
class TableAclArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 access_policies: Optional[pulumi.Input[Sequence[pulumi.Input['TableAclAccessPolicyArgs']]]] = None):
        """
        :param pulumi.Input[str] id: The ID which should be used for this Shared Identifier.
        :param pulumi.Input[Sequence[pulumi.Input['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) -> pulumi.Input[str]:
        """
        The ID which should be used for this Shared Identifier.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @access_policies.setter
    def access_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TableAclAccessPolicyArgs']]]]):
        pulumi.set(self, "access_policies", value)


@pulumi.input_type
class TableAclAccessPolicyArgs:
    def __init__(__self__, *,
                 expiry: pulumi.Input[str],
                 permissions: pulumi.Input[str],
                 start: pulumi.Input[str]):
        """
        :param pulumi.Input[str] expiry: The ISO8061 UTC time at which this Access Policy should be valid until.
        :param pulumi.Input[str] permissions: The permissions which should associated with this Shared Identifier.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ISO8061 UTC time at which this Access Policy should be valid until.
        """
        return pulumi.get(self, "expiry")

    @expiry.setter
    def expiry(self, value: pulumi.Input[str]):
        pulumi.set(self, "expiry", value)

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

    @permissions.setter
    def permissions(self, value: pulumi.Input[str]):
        pulumi.set(self, "permissions", value)

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

    @start.setter
    def start(self, value: pulumi.Input[str]):
        pulumi.set(self, "start", value)


@pulumi.input_type
class GetAccountBlobContainerSASPermissionsArgs:
    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")

    @add.setter
    def add(self, value: bool):
        pulumi.set(self, "add", value)

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

    @create.setter
    def create(self, value: bool):
        pulumi.set(self, "create", value)

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

    @delete.setter
    def delete(self, value: bool):
        pulumi.set(self, "delete", value)

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

    @list.setter
    def list(self, value: bool):
        pulumi.set(self, "list", value)

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

    @read.setter
    def read(self, value: bool):
        pulumi.set(self, "read", value)

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

    @write.setter
    def write(self, value: bool):
        pulumi.set(self, "write", value)


@pulumi.input_type
class GetAccountSASPermissionsArgs:
    def __init__(__self__, *,
                 add: bool,
                 create: bool,
                 delete: bool,
                 filter: bool,
                 list: bool,
                 process: bool,
                 read: bool,
                 tag: 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 filter: Should Filter by Index Tags 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 tag: Should Get / Set Index Tags 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__, "filter", filter)
        pulumi.set(__self__, "list", list)
        pulumi.set(__self__, "process", process)
        pulumi.set(__self__, "read", read)
        pulumi.set(__self__, "tag", tag)
        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")

    @add.setter
    def add(self, value: bool):
        pulumi.set(self, "add", value)

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

    @create.setter
    def create(self, value: bool):
        pulumi.set(self, "create", value)

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

    @delete.setter
    def delete(self, value: bool):
        pulumi.set(self, "delete", value)

    @property
    @pulumi.getter
    def filter(self) -> bool:
        """
        Should Filter by Index Tags permissions be enabled for this SAS?
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: bool):
        pulumi.set(self, "filter", value)

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

    @list.setter
    def list(self, value: bool):
        pulumi.set(self, "list", value)

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

    @process.setter
    def process(self, value: bool):
        pulumi.set(self, "process", value)

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

    @read.setter
    def read(self, value: bool):
        pulumi.set(self, "read", value)

    @property
    @pulumi.getter
    def tag(self) -> bool:
        """
        Should Get / Set Index Tags permissions be enabled for this SAS?
        """
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: bool):
        pulumi.set(self, "tag", value)

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

    @update.setter
    def update(self, value: bool):
        pulumi.set(self, "update", value)

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

    @write.setter
    def write(self, value: bool):
        pulumi.set(self, "write", value)


@pulumi.input_type
class GetAccountSASResourceTypesArgs:
    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")

    @container.setter
    def container(self, value: bool):
        pulumi.set(self, "container", value)

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

    @object.setter
    def object(self, value: bool):
        pulumi.set(self, "object", value)

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

    @service.setter
    def service(self, value: bool):
        pulumi.set(self, "service", value)


@pulumi.input_type
class GetAccountSASServicesArgs:
    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")

    @blob.setter
    def blob(self, value: bool):
        pulumi.set(self, "blob", value)

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

    @file.setter
    def file(self, value: bool):
        pulumi.set(self, "file", value)

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

    @queue.setter
    def queue(self, value: bool):
        pulumi.set(self, "queue", value)

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

    @table.setter
    def table(self, value: bool):
        pulumi.set(self, "table", value)


@pulumi.input_type
class GetShareAclArgs:
    def __init__(__self__, *,
                 access_policies: Sequence['GetShareAclAccessPolicyArgs'],
                 id: str):
        """
        :param Sequence['GetShareAclAccessPolicyArgs'] access_policies: An `access_policy` block as defined below.
        :param str id: The ID which should be used for this Shared Identifier.
        """
        pulumi.set(__self__, "access_policies", access_policies)
        pulumi.set(__self__, "id", id)

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

    @access_policies.setter
    def access_policies(self, value: Sequence['GetShareAclAccessPolicyArgs']):
        pulumi.set(self, "access_policies", value)

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

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


@pulumi.input_type
class GetShareAclAccessPolicyArgs:
    def __init__(__self__, *,
                 expiry: str,
                 permissions: str,
                 start: str):
        """
        :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 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 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__, "expiry", expiry)
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def expiry(self) -> 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")

    @expiry.setter
    def expiry(self, value: str):
        pulumi.set(self, "expiry", value)

    @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")

    @permissions.setter
    def permissions(self, value: str):
        pulumi.set(self, "permissions", value)

    @property
    @pulumi.getter
    def start(self) -> 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")

    @start.setter
    def start(self, value: str):
        pulumi.set(self, "start", value)


