# 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 copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'AccountAzureFilesAuthenticationArgs',
    'AccountAzureFilesAuthenticationArgsDict',
    'AccountAzureFilesAuthenticationActiveDirectoryArgs',
    'AccountAzureFilesAuthenticationActiveDirectoryArgsDict',
    'AccountBlobPropertiesArgs',
    'AccountBlobPropertiesArgsDict',
    'AccountBlobPropertiesContainerDeleteRetentionPolicyArgs',
    'AccountBlobPropertiesContainerDeleteRetentionPolicyArgsDict',
    'AccountBlobPropertiesCorsRuleArgs',
    'AccountBlobPropertiesCorsRuleArgsDict',
    'AccountBlobPropertiesDeleteRetentionPolicyArgs',
    'AccountBlobPropertiesDeleteRetentionPolicyArgsDict',
    'AccountBlobPropertiesRestorePolicyArgs',
    'AccountBlobPropertiesRestorePolicyArgsDict',
    'AccountCustomDomainArgs',
    'AccountCustomDomainArgsDict',
    'AccountCustomerManagedKeyArgs',
    'AccountCustomerManagedKeyArgsDict',
    'AccountIdentityArgs',
    'AccountIdentityArgsDict',
    'AccountImmutabilityPolicyArgs',
    'AccountImmutabilityPolicyArgsDict',
    'AccountNetworkRulesArgs',
    'AccountNetworkRulesArgsDict',
    'AccountNetworkRulesPrivateLinkAccessArgs',
    'AccountNetworkRulesPrivateLinkAccessArgsDict',
    'AccountNetworkRulesPrivateLinkAccessRuleArgs',
    'AccountNetworkRulesPrivateLinkAccessRuleArgsDict',
    'AccountQueuePropertiesArgs',
    'AccountQueuePropertiesArgsDict',
    'AccountQueuePropertiesCorsRuleArgs',
    'AccountQueuePropertiesCorsRuleArgsDict',
    'AccountQueuePropertiesHourMetricsArgs',
    'AccountQueuePropertiesHourMetricsArgsDict',
    'AccountQueuePropertiesLoggingArgs',
    'AccountQueuePropertiesLoggingArgsDict',
    'AccountQueuePropertiesMinuteMetricsArgs',
    'AccountQueuePropertiesMinuteMetricsArgsDict',
    'AccountRoutingArgs',
    'AccountRoutingArgsDict',
    'AccountSasPolicyArgs',
    'AccountSasPolicyArgsDict',
    'AccountSharePropertiesArgs',
    'AccountSharePropertiesArgsDict',
    'AccountSharePropertiesCorsRuleArgs',
    'AccountSharePropertiesCorsRuleArgsDict',
    'AccountSharePropertiesRetentionPolicyArgs',
    'AccountSharePropertiesRetentionPolicyArgsDict',
    'AccountSharePropertiesSmbArgs',
    'AccountSharePropertiesSmbArgsDict',
    'AccountStaticWebsiteArgs',
    'AccountStaticWebsiteArgsDict',
    'BlobInventoryPolicyRuleArgs',
    'BlobInventoryPolicyRuleArgsDict',
    'BlobInventoryPolicyRuleFilterArgs',
    'BlobInventoryPolicyRuleFilterArgsDict',
    'DataLakeGen2FilesystemAceArgs',
    'DataLakeGen2FilesystemAceArgsDict',
    'DataLakeGen2PathAceArgs',
    'DataLakeGen2PathAceArgsDict',
    'LocalUserPermissionScopeArgs',
    'LocalUserPermissionScopeArgsDict',
    'LocalUserPermissionScopePermissionsArgs',
    'LocalUserPermissionScopePermissionsArgsDict',
    'LocalUserSshAuthorizedKeyArgs',
    'LocalUserSshAuthorizedKeyArgsDict',
    'ManagementPolicyRuleArgs',
    'ManagementPolicyRuleArgsDict',
    'ManagementPolicyRuleActionsArgs',
    'ManagementPolicyRuleActionsArgsDict',
    'ManagementPolicyRuleActionsBaseBlobArgs',
    'ManagementPolicyRuleActionsBaseBlobArgsDict',
    'ManagementPolicyRuleActionsSnapshotArgs',
    'ManagementPolicyRuleActionsSnapshotArgsDict',
    'ManagementPolicyRuleActionsVersionArgs',
    'ManagementPolicyRuleActionsVersionArgsDict',
    'ManagementPolicyRuleFiltersArgs',
    'ManagementPolicyRuleFiltersArgsDict',
    'ManagementPolicyRuleFiltersMatchBlobIndexTagArgs',
    'ManagementPolicyRuleFiltersMatchBlobIndexTagArgsDict',
    'ObjectReplicationRuleArgs',
    'ObjectReplicationRuleArgsDict',
    'ShareAclArgs',
    'ShareAclArgsDict',
    'ShareAclAccessPolicyArgs',
    'ShareAclAccessPolicyArgsDict',
    'TableAclArgs',
    'TableAclArgsDict',
    'TableAclAccessPolicyArgs',
    'TableAclAccessPolicyArgsDict',
    'GetAccountBlobContainerSASPermissionsArgs',
    'GetAccountBlobContainerSASPermissionsArgsDict',
    'GetAccountSASPermissionsArgs',
    'GetAccountSASPermissionsArgsDict',
    'GetAccountSASResourceTypesArgs',
    'GetAccountSASResourceTypesArgsDict',
    'GetAccountSASServicesArgs',
    'GetAccountSASServicesArgsDict',
    'GetShareAclArgs',
    'GetShareAclArgsDict',
    'GetShareAclAccessPolicyArgs',
    'GetShareAclAccessPolicyArgsDict',
]

MYPY = False

if not MYPY:
    class AccountAzureFilesAuthenticationArgsDict(TypedDict):
        directory_type: pulumi.Input[str]
        """
        Specifies the directory service used. Possible values are `AADDS`, `AD` and `AADKERB`.
        """
        active_directory: NotRequired[pulumi.Input['AccountAzureFilesAuthenticationActiveDirectoryArgsDict']]
        """
        A `active_directory` block as defined below. Required when `directory_type` is `AD`.
        """
        default_share_level_permission: NotRequired[pulumi.Input[str]]
        """
        Specifies the default share level permissions applied to all users. Possible values are `StorageFileDataSmbShareReader`, `StorageFileDataSmbShareContributor`, `StorageFileDataSmbShareElevatedContributor`, or `None`.
        """
elif False:
    AccountAzureFilesAuthenticationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountAzureFilesAuthenticationArgs:
    def __init__(__self__, *,
                 directory_type: pulumi.Input[str],
                 active_directory: Optional[pulumi.Input['AccountAzureFilesAuthenticationActiveDirectoryArgs']] = None,
                 default_share_level_permission: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] directory_type: Specifies the directory service used. Possible values are `AADDS`, `AD` and `AADKERB`.
        :param pulumi.Input['AccountAzureFilesAuthenticationActiveDirectoryArgs'] active_directory: A `active_directory` block as defined below. Required when `directory_type` is `AD`.
        :param pulumi.Input[str] default_share_level_permission: Specifies the default share level permissions applied to all users. Possible values are `StorageFileDataSmbShareReader`, `StorageFileDataSmbShareContributor`, `StorageFileDataSmbShareElevatedContributor`, or `None`.
        """
        pulumi.set(__self__, "directory_type", directory_type)
        if active_directory is not None:
            pulumi.set(__self__, "active_directory", active_directory)
        if default_share_level_permission is not None:
            pulumi.set(__self__, "default_share_level_permission", default_share_level_permission)

    @property
    @pulumi.getter(name="directoryType")
    def directory_type(self) -> pulumi.Input[str]:
        """
        Specifies the directory service used. Possible values are `AADDS`, `AD` and `AADKERB`.
        """
        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)

    @property
    @pulumi.getter(name="defaultShareLevelPermission")
    def default_share_level_permission(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the default share level permissions applied to all users. Possible values are `StorageFileDataSmbShareReader`, `StorageFileDataSmbShareContributor`, `StorageFileDataSmbShareElevatedContributor`, or `None`.
        """
        return pulumi.get(self, "default_share_level_permission")

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


if not MYPY:
    class AccountAzureFilesAuthenticationActiveDirectoryArgsDict(TypedDict):
        domain_guid: pulumi.Input[str]
        """
        Specifies the domain GUID.
        """
        domain_name: pulumi.Input[str]
        """
        Specifies the primary domain that the AD DNS server is authoritative for.
        """
        domain_sid: NotRequired[pulumi.Input[str]]
        """
        Specifies the security identifier (SID). This is required when `directory_type` is set to `AD`.
        """
        forest_name: NotRequired[pulumi.Input[str]]
        """
        Specifies the Active Directory forest. This is required when `directory_type` is set to `AD`.
        """
        netbios_domain_name: NotRequired[pulumi.Input[str]]
        """
        Specifies the NetBIOS domain name. This is required when `directory_type` is set to `AD`.
        """
        storage_sid: NotRequired[pulumi.Input[str]]
        """
        Specifies the security identifier (SID) for Azure Storage. This is required when `directory_type` is set to `AD`.
        """
elif False:
    AccountAzureFilesAuthenticationActiveDirectoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountAzureFilesAuthenticationActiveDirectoryArgs:
    def __init__(__self__, *,
                 domain_guid: pulumi.Input[str],
                 domain_name: pulumi.Input[str],
                 domain_sid: Optional[pulumi.Input[str]] = None,
                 forest_name: Optional[pulumi.Input[str]] = None,
                 netbios_domain_name: Optional[pulumi.Input[str]] = None,
                 storage_sid: Optional[pulumi.Input[str]] = None):
        """
        :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). This is required when `directory_type` is set to `AD`.
        :param pulumi.Input[str] forest_name: Specifies the Active Directory forest. This is required when `directory_type` is set to `AD`.
        :param pulumi.Input[str] netbios_domain_name: Specifies the NetBIOS domain name. This is required when `directory_type` is set to `AD`.
        :param pulumi.Input[str] storage_sid: Specifies the security identifier (SID) for Azure Storage. This is required when `directory_type` is set to `AD`.
        """
        pulumi.set(__self__, "domain_guid", domain_guid)
        pulumi.set(__self__, "domain_name", domain_name)
        if domain_sid is not None:
            pulumi.set(__self__, "domain_sid", domain_sid)
        if forest_name is not None:
            pulumi.set(__self__, "forest_name", forest_name)
        if netbios_domain_name is not None:
            pulumi.set(__self__, "netbios_domain_name", netbios_domain_name)
        if storage_sid is not None:
            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) -> Optional[pulumi.Input[str]]:
        """
        Specifies the security identifier (SID). This is required when `directory_type` is set to `AD`.
        """
        return pulumi.get(self, "domain_sid")

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

    @property
    @pulumi.getter(name="forestName")
    def forest_name(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Active Directory forest. This is required when `directory_type` is set to `AD`.
        """
        return pulumi.get(self, "forest_name")

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

    @property
    @pulumi.getter(name="netbiosDomainName")
    def netbios_domain_name(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the NetBIOS domain name. This is required when `directory_type` is set to `AD`.
        """
        return pulumi.get(self, "netbios_domain_name")

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

    @property
    @pulumi.getter(name="storageSid")
    def storage_sid(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the security identifier (SID) for Azure Storage. This is required when `directory_type` is set to `AD`.
        """
        return pulumi.get(self, "storage_sid")

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


if not MYPY:
    class AccountBlobPropertiesArgsDict(TypedDict):
        change_feed_enabled: NotRequired[pulumi.Input[bool]]
        """
        Is the blob service properties for change feed events enabled? Default to `false`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        change_feed_retention_in_days: NotRequired[pulumi.Input[int]]
        """
        The duration of change feed events retention in days. The possible values are between 1 and 146000 days (400 years). Setting this to null (or omit this in the configuration file) indicates an infinite retention of the change feed.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        container_delete_retention_policy: NotRequired[pulumi.Input['AccountBlobPropertiesContainerDeleteRetentionPolicyArgsDict']]
        """
        A `container_delete_retention_policy` block as defined below.
        """
        cors_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['AccountBlobPropertiesCorsRuleArgsDict']]]]
        """
        A `cors_rule` block as defined below.
        """
        default_service_version: NotRequired[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.
        """
        delete_retention_policy: NotRequired[pulumi.Input['AccountBlobPropertiesDeleteRetentionPolicyArgsDict']]
        """
        A `delete_retention_policy` block as defined below.
        """
        last_access_time_enabled: NotRequired[pulumi.Input[bool]]
        """
        Is the last access time based tracking enabled? Default to `false`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        restore_policy: NotRequired[pulumi.Input['AccountBlobPropertiesRestorePolicyArgsDict']]
        """
        A `restore_policy` block as defined below. This must be used together with `delete_retention_policy` set, `versioning_enabled` and `change_feed_enabled` set to `true`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).

        > **Note:** `restore_policy` can not be configured when `dns_endpoint_type` is `AzureDnsZone`.
        """
        versioning_enabled: NotRequired[pulumi.Input[bool]]
        """
        Is versioning enabled? Default to `false`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
elif False:
    AccountBlobPropertiesArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountBlobPropertiesArgs:
    def __init__(__self__, *,
                 change_feed_enabled: Optional[pulumi.Input[bool]] = None,
                 change_feed_retention_in_days: Optional[pulumi.Input[int]] = 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,
                 restore_policy: Optional[pulumi.Input['AccountBlobPropertiesRestorePolicyArgs']] = 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`.
               
               > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        :param pulumi.Input[int] change_feed_retention_in_days: The duration of change feed events retention in days. The possible values are between 1 and 146000 days (400 years). Setting this to null (or omit this in the configuration file) indicates an infinite retention of the change feed.
               
               > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        :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.
        :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`.
               
               > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        :param pulumi.Input['AccountBlobPropertiesRestorePolicyArgs'] restore_policy: A `restore_policy` block as defined below. This must be used together with `delete_retention_policy` set, `versioning_enabled` and `change_feed_enabled` set to `true`.
               
               > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
               
               > **Note:** `restore_policy` can not be configured when `dns_endpoint_type` is `AzureDnsZone`.
        :param pulumi.Input[bool] versioning_enabled: Is versioning enabled? Default to `false`.
               
               > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        if change_feed_enabled is not None:
            pulumi.set(__self__, "change_feed_enabled", change_feed_enabled)
        if change_feed_retention_in_days is not None:
            pulumi.set(__self__, "change_feed_retention_in_days", change_feed_retention_in_days)
        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 restore_policy is not None:
            pulumi.set(__self__, "restore_policy", restore_policy)
        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`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        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="changeFeedRetentionInDays")
    def change_feed_retention_in_days(self) -> Optional[pulumi.Input[int]]:
        """
        The duration of change feed events retention in days. The possible values are between 1 and 146000 days (400 years). Setting this to null (or omit this in the configuration file) indicates an infinite retention of the change feed.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        return pulumi.get(self, "change_feed_retention_in_days")

    @change_feed_retention_in_days.setter
    def change_feed_retention_in_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "change_feed_retention_in_days", 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.
        """
        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`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        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="restorePolicy")
    def restore_policy(self) -> Optional[pulumi.Input['AccountBlobPropertiesRestorePolicyArgs']]:
        """
        A `restore_policy` block as defined below. This must be used together with `delete_retention_policy` set, `versioning_enabled` and `change_feed_enabled` set to `true`.

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).

        > **Note:** `restore_policy` can not be configured when `dns_endpoint_type` is `AzureDnsZone`.
        """
        return pulumi.get(self, "restore_policy")

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

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

        > **Note:** This field cannot be configured when `kind` is set to `Storage` (V1).
        """
        return pulumi.get(self, "versioning_enabled")

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


if not MYPY:
    class AccountBlobPropertiesContainerDeleteRetentionPolicyArgsDict(TypedDict):
        days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that the container should be retained, between `1` and `365` days. Defaults to `7`.
        """
elif False:
    AccountBlobPropertiesContainerDeleteRetentionPolicyArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountBlobPropertiesCorsRuleArgsDict(TypedDict):
        allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        allowed_methods: 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`.
        """
        allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of origin domains that will be allowed by CORS.
        """
        exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of response headers that are exposed to CORS clients.
        """
        max_age_in_seconds: pulumi.Input[int]
        """
        The number of seconds the client should cache a preflight response.
        """
elif False:
    AccountBlobPropertiesCorsRuleArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountBlobPropertiesDeleteRetentionPolicyArgsDict(TypedDict):
        days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that the blob should be retained, between `1` and `365` days. Defaults to `7`.
        """
        permanent_delete_enabled: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether permanent deletion of the soft deleted blob versions and snapshots is allowed. Defaults to `false`.

        > **Note:** `permanent_delete_enabled` cannot be set to true if a `restore_policy` block is defined.
        """
elif False:
    AccountBlobPropertiesDeleteRetentionPolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountBlobPropertiesDeleteRetentionPolicyArgs:
    def __init__(__self__, *,
                 days: Optional[pulumi.Input[int]] = None,
                 permanent_delete_enabled: Optional[pulumi.Input[bool]] = 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`.
        :param pulumi.Input[bool] permanent_delete_enabled: Indicates whether permanent deletion of the soft deleted blob versions and snapshots is allowed. Defaults to `false`.
               
               > **Note:** `permanent_delete_enabled` cannot be set to true if a `restore_policy` block is defined.
        """
        if days is not None:
            pulumi.set(__self__, "days", days)
        if permanent_delete_enabled is not None:
            pulumi.set(__self__, "permanent_delete_enabled", permanent_delete_enabled)

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

    @property
    @pulumi.getter(name="permanentDeleteEnabled")
    def permanent_delete_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether permanent deletion of the soft deleted blob versions and snapshots is allowed. Defaults to `false`.

        > **Note:** `permanent_delete_enabled` cannot be set to true if a `restore_policy` block is defined.
        """
        return pulumi.get(self, "permanent_delete_enabled")

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


if not MYPY:
    class AccountBlobPropertiesRestorePolicyArgsDict(TypedDict):
        days: pulumi.Input[int]
        """
        Specifies the number of days that the blob can be restored, between `1` and `365` days. This must be less than the `days` specified for `delete_retention_policy`.
        """
elif False:
    AccountBlobPropertiesRestorePolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountBlobPropertiesRestorePolicyArgs:
    def __init__(__self__, *,
                 days: pulumi.Input[int]):
        """
        :param pulumi.Input[int] days: Specifies the number of days that the blob can be restored, between `1` and `365` days. This must be less than the `days` specified for `delete_retention_policy`.
        """
        pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def days(self) -> pulumi.Input[int]:
        """
        Specifies the number of days that the blob can be restored, between `1` and `365` days. This must be less than the `days` specified for `delete_retention_policy`.
        """
        return pulumi.get(self, "days")

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


if not MYPY:
    class AccountCustomDomainArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The Custom Domain Name to use for the Storage Account, which will be validated by Azure.
        """
        use_subdomain: NotRequired[pulumi.Input[bool]]
        """
        Should the Custom Domain Name be validated by using indirect CNAME validation?
        """
elif False:
    AccountCustomDomainArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountCustomerManagedKeyArgsDict(TypedDict):
        user_assigned_identity_id: pulumi.Input[str]
        """
        The ID of a user assigned identity.

        > **Note:** `customer_managed_key` can only be set when the `account_kind` is set to `StorageV2` or `account_tier` set to `Premium`, and the identity type is `UserAssigned`.
        """
        key_vault_key_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the Key Vault Key, supplying a version-less key ID will enable auto-rotation of this key. Exactly one of `key_vault_key_id` and `managed_hsm_key_id` may be specified.
        """
        managed_hsm_key_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the managed HSM Key. Exactly one of `key_vault_key_id` and `managed_hsm_key_id` may be specified.
        """
elif False:
    AccountCustomerManagedKeyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountCustomerManagedKeyArgs:
    def __init__(__self__, *,
                 user_assigned_identity_id: pulumi.Input[str],
                 key_vault_key_id: Optional[pulumi.Input[str]] = None,
                 managed_hsm_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] user_assigned_identity_id: The ID of a user assigned identity.
               
               > **Note:** `customer_managed_key` can only be set when the `account_kind` is set to `StorageV2` or `account_tier` set to `Premium`, and the identity type is `UserAssigned`.
        :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. Exactly one of `key_vault_key_id` and `managed_hsm_key_id` may be specified.
        :param pulumi.Input[str] managed_hsm_key_id: The ID of the managed HSM Key. Exactly one of `key_vault_key_id` and `managed_hsm_key_id` may be specified.
        """
        pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)
        if key_vault_key_id is not None:
            pulumi.set(__self__, "key_vault_key_id", key_vault_key_id)
        if managed_hsm_key_id is not None:
            pulumi.set(__self__, "managed_hsm_key_id", managed_hsm_key_id)

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

        > **Note:** `customer_managed_key` can only be set when the `account_kind` is set to `StorageV2` or `account_tier` set to `Premium`, and the identity type is `UserAssigned`.
        """
        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)

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

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

    @property
    @pulumi.getter(name="managedHsmKeyId")
    def managed_hsm_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the managed HSM Key. Exactly one of `key_vault_key_id` and `managed_hsm_key_id` may be specified.
        """
        return pulumi.get(self, "managed_hsm_key_id")

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


if not MYPY:
    class AccountIdentityArgsDict(TypedDict):
        type: 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).
        """
        identity_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this Storage Account.

        > **Note:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.

        > The assigned `principal_id` and `tenant_id` can be retrieved after the identity `type` has been set to `SystemAssigned`  and Storage Account has been created. More details are available below.
        """
        principal_id: NotRequired[pulumi.Input[str]]
        """
        The Principal ID for the Service Principal associated with the Identity of this Storage Account.
        """
        tenant_id: NotRequired[pulumi.Input[str]]
        """
        The Tenant ID for the Service Principal associated with the Identity of this Storage Account.
        """
elif False:
    AccountIdentityArgsDict: TypeAlias = Mapping[str, Any]

@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.
               
               > **Note:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
               
               > The assigned `principal_id` and `tenant_id` can be retrieved after the identity `type` has been set to `SystemAssigned`  and Storage Account has been created. More details are available below.
        :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.

        > **Note:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.

        > The assigned `principal_id` and `tenant_id` can be retrieved after the identity `type` has been set to `SystemAssigned`  and Storage Account has been created. More details are available below.
        """
        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)


if not MYPY:
    class AccountImmutabilityPolicyArgsDict(TypedDict):
        allow_protected_append_writes: pulumi.Input[bool]
        """
        When enabled, new blocks can be written to an append blob while maintaining immutability protection and compliance. Only new blocks can be added and any existing blocks cannot be modified or deleted.
        """
        period_since_creation_in_days: pulumi.Input[int]
        """
        The immutability period for the blobs in the container since the policy creation, in days.
        """
        state: pulumi.Input[str]
        """
        Defines the mode of the policy. `Disabled` state disables the policy, `Unlocked` state allows increase and decrease of immutability retention time and also allows toggling allowProtectedAppendWrites property, `Locked` state only allows the increase of the immutability retention time. A policy can only be created in a Disabled or Unlocked state and can be toggled between the two states. Only a policy in an Unlocked state can transition to a Locked state which cannot be reverted.
        """
elif False:
    AccountImmutabilityPolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountImmutabilityPolicyArgs:
    def __init__(__self__, *,
                 allow_protected_append_writes: pulumi.Input[bool],
                 period_since_creation_in_days: pulumi.Input[int],
                 state: pulumi.Input[str]):
        """
        :param pulumi.Input[bool] allow_protected_append_writes: When enabled, new blocks can be written to an append blob while maintaining immutability protection and compliance. Only new blocks can be added and any existing blocks cannot be modified or deleted.
        :param pulumi.Input[int] period_since_creation_in_days: The immutability period for the blobs in the container since the policy creation, in days.
        :param pulumi.Input[str] state: Defines the mode of the policy. `Disabled` state disables the policy, `Unlocked` state allows increase and decrease of immutability retention time and also allows toggling allowProtectedAppendWrites property, `Locked` state only allows the increase of the immutability retention time. A policy can only be created in a Disabled or Unlocked state and can be toggled between the two states. Only a policy in an Unlocked state can transition to a Locked state which cannot be reverted.
        """
        pulumi.set(__self__, "allow_protected_append_writes", allow_protected_append_writes)
        pulumi.set(__self__, "period_since_creation_in_days", period_since_creation_in_days)
        pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="allowProtectedAppendWrites")
    def allow_protected_append_writes(self) -> pulumi.Input[bool]:
        """
        When enabled, new blocks can be written to an append blob while maintaining immutability protection and compliance. Only new blocks can be added and any existing blocks cannot be modified or deleted.
        """
        return pulumi.get(self, "allow_protected_append_writes")

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

    @property
    @pulumi.getter(name="periodSinceCreationInDays")
    def period_since_creation_in_days(self) -> pulumi.Input[int]:
        """
        The immutability period for the blobs in the container since the policy creation, in days.
        """
        return pulumi.get(self, "period_since_creation_in_days")

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

    @property
    @pulumi.getter
    def state(self) -> pulumi.Input[str]:
        """
        Defines the mode of the policy. `Disabled` state disables the policy, `Unlocked` state allows increase and decrease of immutability retention time and also allows toggling allowProtectedAppendWrites property, `Locked` state only allows the increase of the immutability retention time. A policy can only be created in a Disabled or Unlocked state and can be toggled between the two states. Only a policy in an Unlocked state can transition to a Locked state which cannot be reverted.
        """
        return pulumi.get(self, "state")

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


if not MYPY:
    class AccountNetworkRulesArgsDict(TypedDict):
        default_action: pulumi.Input[str]
        """
        Specifies the default action of allow or deny when no other rules match. Valid options are `Deny` or `Allow`.
        """
        bypasses: NotRequired[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`.
        """
        ip_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        List of public IP or IP ranges in CIDR Format. Only IPv4 addresses are allowed. /31 CIDRs, /32 CIDRs, and Private IP address ranges (as defined in [RFC 1918](https://tools.ietf.org/html/rfc1918#section-3)), are not allowed.
        """
        private_link_accesses: NotRequired[pulumi.Input[Sequence[pulumi.Input['AccountNetworkRulesPrivateLinkAccessArgsDict']]]]
        """
        One or more `private_link_access` block as defined below.

        > **Note:** If specifying `network_rules`, one of either `ip_rules` or `virtual_network_subnet_ids` must be specified and `default_action` must be set to `Deny`.

        > **Note:** Network Rules can be defined either directly on the `storage.Account` resource, or using the `storage.AccountNetworkRules` resource - but the two cannot be used together. If both are used against the same Storage Account, spurious changes will occur. When managing Network Rules using this resource, to change from a `default_action` of `Deny` to `Allow` requires defining, rather than removing, the block.

        > **Note:** The prefix of `ip_rules` must be between 0 and 30 and only supports public IP addresses.

        > **Note:** [More information on Validation is available here](https://docs.microsoft.com/en-gb/azure/storage/blobs/storage-custom-domain-name)
        """
        virtual_network_subnet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A list of resource ids for subnets.
        """
elif False:
    AccountNetworkRulesArgsDict: TypeAlias = Mapping[str, Any]

@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. /31 CIDRs, /32 CIDRs, and 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.
               
               > **Note:** If specifying `network_rules`, one of either `ip_rules` or `virtual_network_subnet_ids` must be specified and `default_action` must be set to `Deny`.
               
               > **Note:** Network Rules can be defined either directly on the `storage.Account` resource, or using the `storage.AccountNetworkRules` resource - but the two cannot be used together. If both are used against the same Storage Account, spurious changes will occur. When managing Network Rules using this resource, to change from a `default_action` of `Deny` to `Allow` requires defining, rather than removing, the block.
               
               > **Note:** The prefix of `ip_rules` must be between 0 and 30 and only supports public IP addresses.
               
               > **Note:** [More information on Validation is available here](https://docs.microsoft.com/en-gb/azure/storage/blobs/storage-custom-domain-name)
        :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. /31 CIDRs, /32 CIDRs, and 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.

        > **Note:** If specifying `network_rules`, one of either `ip_rules` or `virtual_network_subnet_ids` must be specified and `default_action` must be set to `Deny`.

        > **Note:** Network Rules can be defined either directly on the `storage.Account` resource, or using the `storage.AccountNetworkRules` resource - but the two cannot be used together. If both are used against the same Storage Account, spurious changes will occur. When managing Network Rules using this resource, to change from a `default_action` of `Deny` to `Allow` requires defining, rather than removing, the block.

        > **Note:** The prefix of `ip_rules` must be between 0 and 30 and only supports public IP addresses.

        > **Note:** [More information on Validation is available here](https://docs.microsoft.com/en-gb/azure/storage/blobs/storage-custom-domain-name)
        """
        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)


if not MYPY:
    class AccountNetworkRulesPrivateLinkAccessArgsDict(TypedDict):
        endpoint_resource_id: pulumi.Input[str]
        """
        The ID of the Azure resource that should be allowed access to the target storage account.
        """
        endpoint_tenant_id: NotRequired[pulumi.Input[str]]
        """
        The tenant id of the resource of the resource access rule to be granted access. Defaults to the current tenant id.
        """
elif False:
    AccountNetworkRulesPrivateLinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@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 ID of the Azure resource that should be allowed access to the target storage account.
        :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 ID of the Azure resource that should be allowed access to the target storage account.
        """
        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)


if not MYPY:
    class AccountNetworkRulesPrivateLinkAccessRuleArgsDict(TypedDict):
        endpoint_resource_id: pulumi.Input[str]
        """
        The resource id of the resource access rule to be granted access.
        """
        endpoint_tenant_id: NotRequired[pulumi.Input[str]]
        """
        The tenant id of the resource of the resource access rule to be granted access. Defaults to the current tenant id.
        """
elif False:
    AccountNetworkRulesPrivateLinkAccessRuleArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountQueuePropertiesArgsDict(TypedDict):
        cors_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['AccountQueuePropertiesCorsRuleArgsDict']]]]
        """
        A `cors_rule` block as defined above.
        """
        hour_metrics: NotRequired[pulumi.Input['AccountQueuePropertiesHourMetricsArgsDict']]
        """
        A `hour_metrics` block as defined below.
        """
        logging: NotRequired[pulumi.Input['AccountQueuePropertiesLoggingArgsDict']]
        """
        A `logging` block as defined below.
        """
        minute_metrics: NotRequired[pulumi.Input['AccountQueuePropertiesMinuteMetricsArgsDict']]
        """
        A `minute_metrics` block as defined below.
        """
elif False:
    AccountQueuePropertiesArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountQueuePropertiesCorsRuleArgsDict(TypedDict):
        allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        allowed_methods: 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`.
        """
        allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of origin domains that will be allowed by CORS.
        """
        exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of response headers that are exposed to CORS clients.
        """
        max_age_in_seconds: pulumi.Input[int]
        """
        The number of seconds the client should cache a preflight response.
        """
elif False:
    AccountQueuePropertiesCorsRuleArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountQueuePropertiesHourMetricsArgsDict(TypedDict):
        version: pulumi.Input[str]
        """
        The version of storage analytics to configure.
        """
        include_apis: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether metrics should generate summary statistics for called API operations.
        """
        retention_policy_days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that logs will be retained.
        """
elif False:
    AccountQueuePropertiesHourMetricsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountQueuePropertiesHourMetricsArgs:
    def __init__(__self__, *,
                 version: pulumi.Input[str],
                 include_apis: Optional[pulumi.Input[bool]] = None,
                 retention_policy_days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] version: The version of storage analytics to configure.
        :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.
        """
        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 version(self) -> pulumi.Input[str]:
        """
        The version of storage analytics to configure.
        """
        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.
        """
        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)


if not MYPY:
    class AccountQueuePropertiesLoggingArgsDict(TypedDict):
        delete: pulumi.Input[bool]
        """
        Indicates whether all delete requests should be logged.
        """
        read: pulumi.Input[bool]
        """
        Indicates whether all read requests should be logged.
        """
        version: pulumi.Input[str]
        """
        The version of storage analytics to configure.
        """
        write: pulumi.Input[bool]
        """
        Indicates whether all write requests should be logged.
        """
        retention_policy_days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that logs will be retained.
        """
elif False:
    AccountQueuePropertiesLoggingArgsDict: TypeAlias = Mapping[str, Any]

@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.
        :param pulumi.Input[bool] read: Indicates whether all read requests should be logged.
        :param pulumi.Input[str] version: The version of storage analytics to configure.
        :param pulumi.Input[bool] write: Indicates whether all write requests should be logged.
        :param pulumi.Input[int] retention_policy_days: Specifies the number of days that logs will be retained.
        """
        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.
        """
        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.
        """
        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.
        """
        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.
        """
        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.
        """
        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)


if not MYPY:
    class AccountQueuePropertiesMinuteMetricsArgsDict(TypedDict):
        version: pulumi.Input[str]
        """
        The version of storage analytics to configure.
        """
        include_apis: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether metrics should generate summary statistics for called API operations.
        """
        retention_policy_days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that logs will be retained.
        """
elif False:
    AccountQueuePropertiesMinuteMetricsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountQueuePropertiesMinuteMetricsArgs:
    def __init__(__self__, *,
                 version: pulumi.Input[str],
                 include_apis: Optional[pulumi.Input[bool]] = None,
                 retention_policy_days: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] version: The version of storage analytics to configure.
        :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.
        """
        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 version(self) -> pulumi.Input[str]:
        """
        The version of storage analytics to configure.
        """
        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.
        """
        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)


if not MYPY:
    class AccountRoutingArgsDict(TypedDict):
        choice: NotRequired[pulumi.Input[str]]
        """
        Specifies the kind of network routing opted by the user. Possible values are `InternetRouting` and `MicrosoftRouting`. Defaults to `MicrosoftRouting`.
        """
        publish_internet_endpoints: NotRequired[pulumi.Input[bool]]
        """
        Should internet routing storage endpoints be published? Defaults to `false`.
        """
        publish_microsoft_endpoints: NotRequired[pulumi.Input[bool]]
        """
        Should Microsoft routing storage endpoints be published? Defaults to `false`.
        """
elif False:
    AccountRoutingArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountSasPolicyArgsDict(TypedDict):
        expiration_period: pulumi.Input[str]
        """
        The SAS expiration period in format of `DD.HH:MM:SS`.
        """
        expiration_action: NotRequired[pulumi.Input[str]]
        """
        The SAS expiration action. The only possible value is `Log` at this moment. Defaults to `Log`.
        """
elif False:
    AccountSasPolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountSasPolicyArgs:
    def __init__(__self__, *,
                 expiration_period: pulumi.Input[str],
                 expiration_action: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] expiration_period: The SAS expiration period in format of `DD.HH:MM:SS`.
        :param pulumi.Input[str] expiration_action: The SAS expiration action. The only possible value is `Log` at this moment. Defaults to `Log`.
        """
        pulumi.set(__self__, "expiration_period", expiration_period)
        if expiration_action is not None:
            pulumi.set(__self__, "expiration_action", expiration_action)

    @property
    @pulumi.getter(name="expirationPeriod")
    def expiration_period(self) -> pulumi.Input[str]:
        """
        The SAS expiration period in format of `DD.HH:MM:SS`.
        """
        return pulumi.get(self, "expiration_period")

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

    @property
    @pulumi.getter(name="expirationAction")
    def expiration_action(self) -> Optional[pulumi.Input[str]]:
        """
        The SAS expiration action. The only possible value is `Log` at this moment. Defaults to `Log`.
        """
        return pulumi.get(self, "expiration_action")

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


if not MYPY:
    class AccountSharePropertiesArgsDict(TypedDict):
        cors_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['AccountSharePropertiesCorsRuleArgsDict']]]]
        """
        A `cors_rule` block as defined below.
        """
        retention_policy: NotRequired[pulumi.Input['AccountSharePropertiesRetentionPolicyArgsDict']]
        """
        A `retention_policy` block as defined below.
        """
        smb: NotRequired[pulumi.Input['AccountSharePropertiesSmbArgsDict']]
        """
        A `smb` block as defined below.
        """
elif False:
    AccountSharePropertiesArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountSharePropertiesCorsRuleArgsDict(TypedDict):
        allowed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of headers that are allowed to be a part of the cross-origin request.
        """
        allowed_methods: 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`.
        """
        allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of origin domains that will be allowed by CORS.
        """
        exposed_headers: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        A list of response headers that are exposed to CORS clients.
        """
        max_age_in_seconds: pulumi.Input[int]
        """
        The number of seconds the client should cache a preflight response.
        """
elif False:
    AccountSharePropertiesCorsRuleArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountSharePropertiesRetentionPolicyArgsDict(TypedDict):
        days: NotRequired[pulumi.Input[int]]
        """
        Specifies the number of days that the `storage.Share` should be retained, between `1` and `365` days. Defaults to `7`.
        """
elif False:
    AccountSharePropertiesRetentionPolicyArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class AccountSharePropertiesSmbArgsDict(TypedDict):
        authentication_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A set of SMB authentication methods. Possible values are `NTLMv2`, and `Kerberos`.
        """
        channel_encryption_types: NotRequired[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`.
        """
        kerberos_ticket_encryption_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A set of Kerberos ticket encryption. Possible values are `RC4-HMAC`, and `AES-256`.
        """
        multichannel_enabled: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether multichannel is enabled. Defaults to `false`. This is only supported on Premium storage accounts.
        """
        versions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A set of SMB protocol versions. Possible values are `SMB2.1`, `SMB3.0`, and `SMB3.1.1`.
        """
elif False:
    AccountSharePropertiesSmbArgsDict: TypeAlias = Mapping[str, Any]

@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,
                 multichannel_enabled: Optional[pulumi.Input[bool]] = 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[bool] multichannel_enabled: Indicates whether multichannel is enabled. Defaults to `false`. This is only supported on Premium storage accounts.
        :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 multichannel_enabled is not None:
            pulumi.set(__self__, "multichannel_enabled", multichannel_enabled)
        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(name="multichannelEnabled")
    def multichannel_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether multichannel is enabled. Defaults to `false`. This is only supported on Premium storage accounts.
        """
        return pulumi.get(self, "multichannel_enabled")

    @multichannel_enabled.setter
    def multichannel_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "multichannel_enabled", 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)


if not MYPY:
    class AccountStaticWebsiteArgsDict(TypedDict):
        error404_document: NotRequired[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.
        """
        index_document: NotRequired[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.
        """
elif False:
    AccountStaticWebsiteArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class BlobInventoryPolicyRuleArgsDict(TypedDict):
        format: pulumi.Input[str]
        """
        The format of the inventory files. Possible values are `Csv` and `Parquet`.
        """
        name: pulumi.Input[str]
        """
        The name which should be used for this Blob Inventory Policy Rule.
        """
        schedule: pulumi.Input[str]
        """
        The inventory schedule applied by this rule. Possible values are `Daily` and `Weekly`.
        """
        schema_fields: 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.
        """
        scope: pulumi.Input[str]
        """
        The scope of the inventory for this rule. Possible values are `Blob` and `Container`.
        """
        storage_container_name: pulumi.Input[str]
        """
        The storage container name to store the blob inventory files for this rule.
        """
        filter: NotRequired[pulumi.Input['BlobInventoryPolicyRuleFilterArgsDict']]
        """
        A `filter` block as defined above.
        """
elif False:
    BlobInventoryPolicyRuleArgsDict: TypeAlias = Mapping[str, Any]

@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.
        """
        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.
        """
        return pulumi.get(self, "filter")

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


if not MYPY:
    class BlobInventoryPolicyRuleFilterArgsDict(TypedDict):
        blob_types: 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`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `BlobType` so that you can specify the `blob_types`.
        """
        exclude_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A set of strings for blob prefixes to be excluded. Maximum of 10 blob prefixes.
        """
        include_blob_versions: NotRequired[pulumi.Input[bool]]
        """
        Includes blob versions in blob inventory or not? Defaults to `false`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `IsCurrentVersion` and `VersionId` so that you can specify the `include_blob_versions`.
        """
        include_deleted: NotRequired[pulumi.Input[bool]]
        """
        Includes deleted blobs in blob inventory or not? Defaults to `false`.

        > **NOTE:** If `rules.*.scope` is `Container`, the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob`, the `rules.*.schema_fields` must include `Deleted` and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob` and the storage account specified by `storage_account_id` has hierarchical namespaces enabled (`is_hns_enabled` is `true` on the storage account), the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`.
        """
        include_snapshots: NotRequired[pulumi.Input[bool]]
        """
        Includes blob snapshots in blob inventory or not? Defaults to `false`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `Snapshot` so that you can specify the `include_snapshots`.
        """
        prefix_matches: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A set of strings for blob prefixes to be matched. Maximum of 10 blob prefixes.
        """
elif False:
    BlobInventoryPolicyRuleFilterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BlobInventoryPolicyRuleFilterArgs:
    def __init__(__self__, *,
                 blob_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                 exclude_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_blob_versions: Optional[pulumi.Input[bool]] = None,
                 include_deleted: 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`.
               
               > **NOTE:** The `rules.*.schema_fields` for this rule has to include `BlobType` so that you can specify the `blob_types`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_prefixes: A set of strings for blob prefixes to be excluded. Maximum of 10 blob prefixes.
        :param pulumi.Input[bool] include_blob_versions: Includes blob versions in blob inventory or not? Defaults to `false`.
               
               > **NOTE:** The `rules.*.schema_fields` for this rule has to include `IsCurrentVersion` and `VersionId` so that you can specify the `include_blob_versions`.
        :param pulumi.Input[bool] include_deleted: Includes deleted blobs in blob inventory or not? Defaults to `false`.
               
               > **NOTE:** If `rules.*.scope` is `Container`, the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob`, the `rules.*.schema_fields` must include `Deleted` and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob` and the storage account specified by `storage_account_id` has hierarchical namespaces enabled (`is_hns_enabled` is `true` on the storage account), the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`.
        :param pulumi.Input[bool] include_snapshots: Includes blob snapshots in blob inventory or not? Defaults to `false`.
               
               > **NOTE:** The `rules.*.schema_fields` for this rule has to include `Snapshot` so that you can specify the `include_snapshots`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] prefix_matches: A set of strings for blob prefixes to be matched. Maximum of 10 blob prefixes.
        """
        pulumi.set(__self__, "blob_types", blob_types)
        if exclude_prefixes is not None:
            pulumi.set(__self__, "exclude_prefixes", exclude_prefixes)
        if include_blob_versions is not None:
            pulumi.set(__self__, "include_blob_versions", include_blob_versions)
        if include_deleted is not None:
            pulumi.set(__self__, "include_deleted", include_deleted)
        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`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `BlobType` so that you can specify the `blob_types`.
        """
        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="excludePrefixes")
    def exclude_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A set of strings for blob prefixes to be excluded. Maximum of 10 blob prefixes.
        """
        return pulumi.get(self, "exclude_prefixes")

    @exclude_prefixes.setter
    def exclude_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_prefixes", 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`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `IsCurrentVersion` and `VersionId` so that you can specify the `include_blob_versions`.
        """
        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="includeDeleted")
    def include_deleted(self) -> Optional[pulumi.Input[bool]]:
        """
        Includes deleted blobs in blob inventory or not? Defaults to `false`.

        > **NOTE:** If `rules.*.scope` is `Container`, the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob`, the `rules.*.schema_fields` must include `Deleted` and `RemainingRetentionDays` so that you can specify the `include_deleted`. If `rules.*.scope` is `Blob` and the storage account specified by `storage_account_id` has hierarchical namespaces enabled (`is_hns_enabled` is `true` on the storage account), the `rules.*.schema_fields` for this rule must include `Deleted`, `Version`, `DeletedTime`, and `RemainingRetentionDays` so that you can specify the `include_deleted`.
        """
        return pulumi.get(self, "include_deleted")

    @include_deleted.setter
    def include_deleted(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_deleted", 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`.

        > **NOTE:** The `rules.*.schema_fields` for this rule has to include `Snapshot` so that you can specify the `include_snapshots`.
        """
        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. Maximum of 10 blob prefixes.
        """
        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)


if not MYPY:
    class DataLakeGen2FilesystemAceArgsDict(TypedDict):
        permissions: pulumi.Input[str]
        """
        Specifies the permissions for the entry in `rwx` form. For example, `rwx` gives full permissions but `r--` only gives read permissions.

        More details on ACLs can be found here: <https://docs.microsoft.com/azure/storage/blobs/data-lake-storage-access-control#access-control-lists-on-files-and-directories>
        """
        type: pulumi.Input[str]
        """
        Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        """
        id: NotRequired[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.
        """
        scope: NotRequired[pulumi.Input[str]]
        """
        Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
elif False:
    DataLakeGen2FilesystemAceArgsDict: TypeAlias = Mapping[str, Any]

@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.
               
               More details on ACLs can be found here: <https://docs.microsoft.com/azure/storage/blobs/data-lake-storage-access-control#access-control-lists-on-files-and-directories>
        :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.

        More details on ACLs can be found here: <https://docs.microsoft.com/azure/storage/blobs/data-lake-storage-access-control#access-control-lists-on-files-and-directories>
        """
        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)


if not MYPY:
    class DataLakeGen2PathAceArgsDict(TypedDict):
        permissions: pulumi.Input[str]
        type: pulumi.Input[str]
        """
        Specifies the type of entry. Can be `user`, `group`, `mask` or `other`.
        """
        id: NotRequired[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.
        """
        scope: NotRequired[pulumi.Input[str]]
        """
        Specifies whether the ACE represents an `access` entry or a `default` entry. Default value is `access`.
        """
elif False:
    DataLakeGen2PathAceArgsDict: TypeAlias = Mapping[str, Any]

@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] 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]:
        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)


if not MYPY:
    class LocalUserPermissionScopeArgsDict(TypedDict):
        permissions: pulumi.Input['LocalUserPermissionScopePermissionsArgsDict']
        """
        A `permissions` block as defined below.
        """
        resource_name: pulumi.Input[str]
        """
        The container name (when `service` is set to `blob`) or the file share name (when `service` is set to `file`), used by the Storage Account Local User.
        """
        service: pulumi.Input[str]
        """
        The storage service used by this Storage Account Local User. Possible values are `blob` and `file`.
        """
elif False:
    LocalUserPermissionScopeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LocalUserPermissionScopeArgs:
    def __init__(__self__, *,
                 permissions: pulumi.Input['LocalUserPermissionScopePermissionsArgs'],
                 resource_name: pulumi.Input[str],
                 service: pulumi.Input[str]):
        """
        :param pulumi.Input['LocalUserPermissionScopePermissionsArgs'] permissions: A `permissions` block as defined below.
        :param pulumi.Input[str] resource_name: The container name (when `service` is set to `blob`) or the file share name (when `service` is set to `file`), used by the Storage Account Local User.
        :param pulumi.Input[str] service: The storage service used by this Storage Account Local User. Possible values are `blob` and `file`.
        """
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "resource_name", resource_name)
        pulumi.set(__self__, "service", service)

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

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

    @property
    @pulumi.getter(name="resourceName")
    def resource_name(self) -> pulumi.Input[str]:
        """
        The container name (when `service` is set to `blob`) or the file share name (when `service` is set to `file`), used by the Storage Account Local User.
        """
        return pulumi.get(self, "resource_name")

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

    @property
    @pulumi.getter
    def service(self) -> pulumi.Input[str]:
        """
        The storage service used by this Storage Account Local User. Possible values are `blob` and `file`.
        """
        return pulumi.get(self, "service")

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


if not MYPY:
    class LocalUserPermissionScopePermissionsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the Local User has the create permission for this scope. Defaults to `false`.
        """
        delete: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the Local User has the delete permission for this scope. Defaults to `false`.
        """
        list: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the Local User has the list permission for this scope. Defaults to `false`.
        """
        read: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the Local User has the read permission for this scope. Defaults to `false`.
        """
        write: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the Local User has the write permission for this scope. Defaults to `false`.
        """
elif False:
    LocalUserPermissionScopePermissionsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LocalUserPermissionScopePermissionsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[bool]] = None,
                 delete: Optional[pulumi.Input[bool]] = None,
                 list: Optional[pulumi.Input[bool]] = None,
                 read: Optional[pulumi.Input[bool]] = None,
                 write: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] create: Specifies if the Local User has the create permission for this scope. Defaults to `false`.
        :param pulumi.Input[bool] delete: Specifies if the Local User has the delete permission for this scope. Defaults to `false`.
        :param pulumi.Input[bool] list: Specifies if the Local User has the list permission for this scope. Defaults to `false`.
        :param pulumi.Input[bool] read: Specifies if the Local User has the read permission for this scope. Defaults to `false`.
        :param pulumi.Input[bool] write: Specifies if the Local User has the write permission for this scope. Defaults to `false`.
        """
        if create is not None:
            pulumi.set(__self__, "create", create)
        if delete is not None:
            pulumi.set(__self__, "delete", delete)
        if list is not None:
            pulumi.set(__self__, "list", list)
        if read is not None:
            pulumi.set(__self__, "read", read)
        if write is not None:
            pulumi.set(__self__, "write", write)

    @property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the Local User has the create permission for this scope. Defaults to `false`.
        """
        return pulumi.get(self, "create")

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

    @property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the Local User has the delete permission for this scope. Defaults to `false`.
        """
        return pulumi.get(self, "delete")

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

    @property
    @pulumi.getter
    def list(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the Local User has the list permission for this scope. Defaults to `false`.
        """
        return pulumi.get(self, "list")

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

    @property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the Local User has the read permission for this scope. Defaults to `false`.
        """
        return pulumi.get(self, "read")

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

    @property
    @pulumi.getter
    def write(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the Local User has the write permission for this scope. Defaults to `false`.
        """
        return pulumi.get(self, "write")

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


if not MYPY:
    class LocalUserSshAuthorizedKeyArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The public key value of this SSH authorized key.
        """
        description: NotRequired[pulumi.Input[str]]
        """
        The description of this SSH authorized key.
        """
elif False:
    LocalUserSshAuthorizedKeyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LocalUserSshAuthorizedKeyArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: The public key value of this SSH authorized key.
        :param pulumi.Input[str] description: The description of this SSH authorized key.
        """
        pulumi.set(__self__, "key", key)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The public key value of this SSH authorized key.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        The description of this SSH authorized key.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class ManagementPolicyRuleArgsDict(TypedDict):
        actions: pulumi.Input['ManagementPolicyRuleActionsArgsDict']
        """
        An `actions` block as documented below.
        """
        enabled: pulumi.Input[bool]
        """
        Boolean to specify whether the rule is enabled.
        """
        filters: pulumi.Input['ManagementPolicyRuleFiltersArgsDict']
        """
        A `filters` block as documented below.
        """
        name: pulumi.Input[str]
        """
        The name of the rule. Rule name is case-sensitive. It must be unique within a policy.
        """
elif False:
    ManagementPolicyRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ManagementPolicyRuleArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input['ManagementPolicyRuleActionsArgs'],
                 enabled: pulumi.Input[bool],
                 filters: pulumi.Input['ManagementPolicyRuleFiltersArgs'],
                 name: pulumi.Input[str]):
        """
        :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['ManagementPolicyRuleFiltersArgs'] filters: A `filters` block as documented below.
        :param pulumi.Input[str] name: The name of the rule. Rule name is case-sensitive. It must be unique within a policy.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "filters", filters)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def actions(self) -> 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 filters(self) -> pulumi.Input['ManagementPolicyRuleFiltersArgs']:
        """
        A `filters` block as documented below.
        """
        return pulumi.get(self, "filters")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the rule. 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)


if not MYPY:
    class ManagementPolicyRuleActionsArgsDict(TypedDict):
        base_blob: NotRequired[pulumi.Input['ManagementPolicyRuleActionsBaseBlobArgsDict']]
        """
        A `base_blob` block as documented below.
        """
        snapshot: NotRequired[pulumi.Input['ManagementPolicyRuleActionsSnapshotArgsDict']]
        """
        A `snapshot` block as documented below.
        """
        version: NotRequired[pulumi.Input['ManagementPolicyRuleActionsVersionArgsDict']]
        """
        A `version` block as documented below.
        """
elif False:
    ManagementPolicyRuleActionsArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class ManagementPolicyRuleActionsBaseBlobArgsDict(TypedDict):
        auto_tier_to_hot_from_cool_enabled: NotRequired[pulumi.Input[bool]]
        """
        Whether a blob should automatically be tiered from cool back to hot if it's accessed again after being tiered to cool. Defaults to `false`.

        > **Note:** The `auto_tier_to_hot_from_cool_enabled` must be used together with `tier_to_cool_after_days_since_last_access_time_greater_than`.
        """
        delete_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to delete the blob. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `delete_after_days_since_modification_greater_than`, `delete_after_days_since_last_access_time_greater_than` and `delete_after_days_since_creation_greater_than` can not be set at the same time.

        > **Note:** The `last_access_time_enabled` must be set to `true` in the `storage.Account` in order to use `tier_to_cool_after_days_since_last_access_time_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `delete_after_days_since_last_access_time_greater_than`.
        """
        delete_after_days_since_last_access_time_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last access time to delete the blob. Must be between `0` and `99999`. Defaults to `-1`.
        """
        delete_after_days_since_modification_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last modification to delete the blob. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_archive_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to archive storage. Supports blob currently at Hot or Cool tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_archive_after_days_since_modification_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `tier_to_archive_after_days_since_creation_greater_than` can not be set at the same time.
        """
        tier_to_archive_after_days_since_last_access_time_greater_than: NotRequired[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`. Defaults to `-1`.
        """
        tier_to_archive_after_days_since_last_tier_change_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_archive_after_days_since_modification_greater_than: NotRequired[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`. Defaults to `-1`.
        """
        tier_to_cold_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        """
        tier_to_cold_after_days_since_last_access_time_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last access time to tier blobs to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_cold_after_days_since_modification_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last modification to tier blobs to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_cool_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to cool storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        """
        tier_to_cool_after_days_since_last_access_time_greater_than: NotRequired[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`. Defaults to `-1`.
        """
        tier_to_cool_after_days_since_modification_greater_than: NotRequired[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`. Defaults to `-1`.
        """
elif False:
    ManagementPolicyRuleActionsBaseBlobArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ManagementPolicyRuleActionsBaseBlobArgs:
    def __init__(__self__, *,
                 auto_tier_to_hot_from_cool_enabled: Optional[pulumi.Input[bool]] = None,
                 delete_after_days_since_creation_greater_than: Optional[pulumi.Input[int]] = None,
                 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_creation_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_last_tier_change_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_archive_after_days_since_modification_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cold_after_days_since_creation_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cold_after_days_since_last_access_time_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cold_after_days_since_modification_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cool_after_days_since_creation_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[bool] auto_tier_to_hot_from_cool_enabled: Whether a blob should automatically be tiered from cool back to hot if it's accessed again after being tiered to cool. Defaults to `false`.
               
               > **Note:** The `auto_tier_to_hot_from_cool_enabled` must be used together with `tier_to_cool_after_days_since_last_access_time_greater_than`.
        :param pulumi.Input[int] delete_after_days_since_creation_greater_than: The age in days after creation to delete the blob. Must be between `0` and `99999`. Defaults to `-1`.
               
               > **Note:** The `delete_after_days_since_modification_greater_than`, `delete_after_days_since_last_access_time_greater_than` and `delete_after_days_since_creation_greater_than` can not be set at the same time.
               
               > **Note:** The `last_access_time_enabled` must be set to `true` in the `storage.Account` in order to use `tier_to_cool_after_days_since_last_access_time_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `delete_after_days_since_last_access_time_greater_than`.
        :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`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_archive_after_days_since_creation_greater_than: The age in days after creation to archive storage. Supports blob currently at Hot or Cool tier. Must be between `0` and `99999`. Defaults to `-1`.
               
               > **Note:** The `tier_to_archive_after_days_since_modification_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `tier_to_archive_after_days_since_creation_greater_than` can not be set at the same time.
        :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`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_archive_after_days_since_last_tier_change_greater_than: The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_cold_after_days_since_creation_greater_than: The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
               
               > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        :param pulumi.Input[int] tier_to_cold_after_days_since_last_access_time_greater_than: The age in days after last access time to tier blobs to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_cold_after_days_since_modification_greater_than: The age in days after last modification to tier blobs to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_cool_after_days_since_creation_greater_than: The age in days after creation to cool storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
               
               > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        :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`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        """
        if auto_tier_to_hot_from_cool_enabled is not None:
            pulumi.set(__self__, "auto_tier_to_hot_from_cool_enabled", auto_tier_to_hot_from_cool_enabled)
        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)
        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_creation_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_creation_greater_than", tier_to_archive_after_days_since_creation_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_last_tier_change_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_last_tier_change_greater_than", tier_to_archive_after_days_since_last_tier_change_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_cold_after_days_since_creation_greater_than is not None:
            pulumi.set(__self__, "tier_to_cold_after_days_since_creation_greater_than", tier_to_cold_after_days_since_creation_greater_than)
        if tier_to_cold_after_days_since_last_access_time_greater_than is not None:
            pulumi.set(__self__, "tier_to_cold_after_days_since_last_access_time_greater_than", tier_to_cold_after_days_since_last_access_time_greater_than)
        if tier_to_cold_after_days_since_modification_greater_than is not None:
            pulumi.set(__self__, "tier_to_cold_after_days_since_modification_greater_than", tier_to_cold_after_days_since_modification_greater_than)
        if tier_to_cool_after_days_since_creation_greater_than is not None:
            pulumi.set(__self__, "tier_to_cool_after_days_since_creation_greater_than", tier_to_cool_after_days_since_creation_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="autoTierToHotFromCoolEnabled")
    def auto_tier_to_hot_from_cool_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether a blob should automatically be tiered from cool back to hot if it's accessed again after being tiered to cool. Defaults to `false`.

        > **Note:** The `auto_tier_to_hot_from_cool_enabled` must be used together with `tier_to_cool_after_days_since_last_access_time_greater_than`.
        """
        return pulumi.get(self, "auto_tier_to_hot_from_cool_enabled")

    @auto_tier_to_hot_from_cool_enabled.setter
    def auto_tier_to_hot_from_cool_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_tier_to_hot_from_cool_enabled", 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. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `delete_after_days_since_modification_greater_than`, `delete_after_days_since_last_access_time_greater_than` and `delete_after_days_since_creation_greater_than` can not be set at the same time.

        > **Note:** The `last_access_time_enabled` must be set to `true` in the `storage.Account` in order to use `tier_to_cool_after_days_since_last_access_time_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `delete_after_days_since_last_access_time_greater_than`.
        """
        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)

    @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`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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="tierToArchiveAfterDaysSinceCreationGreaterThan")
    def tier_to_archive_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after creation to archive storage. Supports blob currently at Hot or Cool tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_archive_after_days_since_modification_greater_than`, `tier_to_archive_after_days_since_last_access_time_greater_than` and `tier_to_archive_after_days_since_creation_greater_than` can not be set at the same time.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_creation_greater_than")

    @tier_to_archive_after_days_since_creation_greater_than.setter
    def tier_to_archive_after_days_since_creation_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_archive_after_days_since_creation_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`. Defaults to `-1`.
        """
        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="tierToArchiveAfterDaysSinceLastTierChangeGreaterThan")
    def tier_to_archive_after_days_since_last_tier_change_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_last_tier_change_greater_than")

    @tier_to_archive_after_days_since_last_tier_change_greater_than.setter
    def tier_to_archive_after_days_since_last_tier_change_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_archive_after_days_since_last_tier_change_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`. Defaults to `-1`.
        """
        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="tierToColdAfterDaysSinceCreationGreaterThan")
    def tier_to_cold_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        """
        return pulumi.get(self, "tier_to_cold_after_days_since_creation_greater_than")

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

    @property
    @pulumi.getter(name="tierToColdAfterDaysSinceLastAccessTimeGreaterThan")
    def tier_to_cold_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 cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_cold_after_days_since_last_access_time_greater_than")

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

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

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

    @property
    @pulumi.getter(name="tierToCoolAfterDaysSinceCreationGreaterThan")
    def tier_to_cool_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after creation to cool storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.

        > **Note:** The `tier_to_cool_after_days_since_modification_greater_than`, `tier_to_cool_after_days_since_last_access_time_greater_than` and `tier_to_cool_after_days_since_creation_greater_than` can not be set at the same time.
        """
        return pulumi.get(self, "tier_to_cool_after_days_since_creation_greater_than")

    @tier_to_cool_after_days_since_creation_greater_than.setter
    def tier_to_cool_after_days_since_creation_greater_than(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tier_to_cool_after_days_since_creation_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`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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)


if not MYPY:
    class ManagementPolicyRuleActionsSnapshotArgsDict(TypedDict):
        change_tier_to_archive_after_days_since_creation: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to tier blob snapshot to archive storage. Must be between `0` and `99999`. Defaults to `-1`.
        """
        change_tier_to_cool_after_days_since_creation: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to tier blob snapshot to cool storage. Must be between `0` and `99999`. Defaults to `-1`.
        """
        delete_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to delete the blob snapshot. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_archive_after_days_since_last_tier_change_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_cold_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
elif False:
    ManagementPolicyRuleActionsSnapshotArgsDict: TypeAlias = Mapping[str, Any]

@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,
                 tier_to_archive_after_days_since_last_tier_change_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cold_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`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_archive_after_days_since_last_tier_change_greater_than: The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_cold_after_days_since_creation_greater_than: The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        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)
        if tier_to_archive_after_days_since_last_tier_change_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_last_tier_change_greater_than", tier_to_archive_after_days_since_last_tier_change_greater_than)
        if tier_to_cold_after_days_since_creation_greater_than is not None:
            pulumi.set(__self__, "tier_to_cold_after_days_since_creation_greater_than", tier_to_cold_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`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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)

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceLastTierChangeGreaterThan")
    def tier_to_archive_after_days_since_last_tier_change_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_last_tier_change_greater_than")

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

    @property
    @pulumi.getter(name="tierToColdAfterDaysSinceCreationGreaterThan")
    def tier_to_cold_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_cold_after_days_since_creation_greater_than")

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


if not MYPY:
    class ManagementPolicyRuleActionsVersionArgsDict(TypedDict):
        change_tier_to_archive_after_days_since_creation: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to tier blob version to archive storage. Must be between `0` and `99999`. Defaults to `-1`.
        """
        change_tier_to_cool_after_days_since_creation: NotRequired[pulumi.Input[int]]
        """
        The age in days creation create to tier blob version to cool storage. Must be between `0` and `99999`. Defaults to `-1`.
        """
        delete_after_days_since_creation: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to delete the blob version. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_archive_after_days_since_last_tier_change_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        tier_to_cold_after_days_since_creation_greater_than: NotRequired[pulumi.Input[int]]
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
elif False:
    ManagementPolicyRuleActionsVersionArgsDict: TypeAlias = Mapping[str, Any]

@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,
                 tier_to_archive_after_days_since_last_tier_change_greater_than: Optional[pulumi.Input[int]] = None,
                 tier_to_cold_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 version to archive storage. Must be between `0` and `99999`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :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`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_archive_after_days_since_last_tier_change_greater_than: The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        :param pulumi.Input[int] tier_to_cold_after_days_since_creation_greater_than: The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        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)
        if tier_to_archive_after_days_since_last_tier_change_greater_than is not None:
            pulumi.set(__self__, "tier_to_archive_after_days_since_last_tier_change_greater_than", tier_to_archive_after_days_since_last_tier_change_greater_than)
        if tier_to_cold_after_days_since_creation_greater_than is not None:
            pulumi.set(__self__, "tier_to_cold_after_days_since_creation_greater_than", tier_to_cold_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 version to archive storage. Must be between `0` and `99999`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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`. Defaults to `-1`.
        """
        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)

    @property
    @pulumi.getter(name="tierToArchiveAfterDaysSinceLastTierChangeGreaterThan")
    def tier_to_archive_after_days_since_last_tier_change_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after last tier change to the blobs to skip to be archved. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_archive_after_days_since_last_tier_change_greater_than")

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

    @property
    @pulumi.getter(name="tierToColdAfterDaysSinceCreationGreaterThan")
    def tier_to_cold_after_days_since_creation_greater_than(self) -> Optional[pulumi.Input[int]]:
        """
        The age in days after creation to cold storage. Supports blob currently at Hot tier. Must be between `0` and `99999`. Defaults to `-1`.
        """
        return pulumi.get(self, "tier_to_cold_after_days_since_creation_greater_than")

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


if not MYPY:
    class ManagementPolicyRuleFiltersArgsDict(TypedDict):
        blob_types: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        An array of predefined values. Valid options are `blockBlob` and `appendBlob`.
        """
        match_blob_index_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['ManagementPolicyRuleFiltersMatchBlobIndexTagArgsDict']]]]
        """
        A `match_blob_index_tag` block as defined below. The block defines the blob index tag based filtering for blob objects.

        > **NOTE:** The `match_blob_index_tag` property requires enabling the `blobIndex` feature with [PSH or CLI commands](https://azure.microsoft.com/en-us/blog/manage-and-find-data-with-blob-index-for-azure-storage-now-in-preview/).
        """
        prefix_matches: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        An array of strings for prefixes to be matched.
        """
elif False:
    ManagementPolicyRuleFiltersArgsDict: TypeAlias = Mapping[str, Any]

@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.
               
               > **NOTE:** The `match_blob_index_tag` property requires enabling the `blobIndex` feature with [PSH or CLI commands](https://azure.microsoft.com/en-us/blog/manage-and-find-data-with-blob-index-for-azure-storage-now-in-preview/).
        :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.

        > **NOTE:** The `match_blob_index_tag` property requires enabling the `blobIndex` feature with [PSH or CLI commands](https://azure.microsoft.com/en-us/blog/manage-and-find-data-with-blob-index-for-azure-storage-now-in-preview/).
        """
        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)


if not MYPY:
    class ManagementPolicyRuleFiltersMatchBlobIndexTagArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The filter tag name used for tag based filtering for blob objects.
        """
        value: pulumi.Input[str]
        """
        The filter tag value used for tag based filtering for blob objects.
        """
        operation: NotRequired[pulumi.Input[str]]
        """
        The comparison operator which is used for object comparison and filtering. Possible value is `==`. Defaults to `==`.
        """
elif False:
    ManagementPolicyRuleFiltersMatchBlobIndexTagArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class ObjectReplicationRuleArgsDict(TypedDict):
        destination_container_name: pulumi.Input[str]
        """
        The destination storage container name.
        """
        source_container_name: pulumi.Input[str]
        """
        The source storage container name.
        """
        copy_blobs_created_after: NotRequired[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`. Defaults to `OnlyNewObjects`.
        """
        filter_out_blobs_with_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of filters prefixes, the blobs whose names begin with which will be replicated.
        """
        name: NotRequired[pulumi.Input[str]]
elif False:
    ObjectReplicationRuleArgsDict: TypeAlias = Mapping[str, Any]

@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.
        :param pulumi.Input[str] source_container_name: The source storage container name.
        :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`. Defaults to `OnlyNewObjects`.
        :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.
        """
        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.
        """
        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`. Defaults to `OnlyNewObjects`.
        """
        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)


if not MYPY:
    class ShareAclArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID which should be used for this Shared Identifier.
        """
        access_policies: NotRequired[pulumi.Input[Sequence[pulumi.Input['ShareAclAccessPolicyArgsDict']]]]
        """
        An `access_policy` block as defined below.
        """
elif False:
    ShareAclArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class ShareAclAccessPolicyArgsDict(TypedDict):
        permissions: 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).

        > **Note:** Permission order is strict at the service side, and permissions need to be listed in the order above.
        """
        expiry: NotRequired[pulumi.Input[str]]
        """
        The time at which this Access Policy should be valid untilWhen using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        """
        start: NotRequired[pulumi.Input[str]]
        """
        The time at which this Access Policy should be valid from. When using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) format.
        """
elif False:
    ShareAclAccessPolicyArgsDict: TypeAlias = Mapping[str, Any]

@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).
               
               > **Note:** Permission order is strict at the service side, and permissions need to be listed in the order above.
        :param pulumi.Input[str] expiry: The time at which this Access Policy should be valid untilWhen using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [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. When using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [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).

        > **Note:** Permission order is strict at the service side, and permissions need to be listed in the order above.
        """
        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 untilWhen using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [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. When using `storage_account_id` this should be in RFC3339 format. If using the deprecated `storage_account_name` property, this uses the [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)


if not MYPY:
    class TableAclArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID which should be used for this Shared Identifier.
        """
        access_policies: NotRequired[pulumi.Input[Sequence[pulumi.Input['TableAclAccessPolicyArgsDict']]]]
        """
        An `access_policy` block as defined below.
        """
elif False:
    TableAclArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class TableAclAccessPolicyArgsDict(TypedDict):
        expiry: pulumi.Input[str]
        """
        The ISO8061 UTC time at which this Access Policy should be valid until.
        """
        permissions: pulumi.Input[str]
        """
        The permissions which should associated with this Shared Identifier.
        """
        start: pulumi.Input[str]
        """
        The ISO8061 UTC time at which this Access Policy should be valid from.
        """
elif False:
    TableAclAccessPolicyArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class GetAccountBlobContainerSASPermissionsArgsDict(TypedDict):
        add: bool
        """
        Should Add permissions be enabled for this SAS?
        """
        create: bool
        """
        Should Create permissions be enabled for this SAS?
        """
        delete: bool
        """
        Should Delete permissions be enabled for this SAS?
        """
        list: bool
        """
        Should List permissions be enabled for this SAS?

        Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/create-service-sas)
        for additional details on the fields above.
        """
        read: bool
        """
        Should Read permissions be enabled for this SAS?
        """
        write: bool
        """
        Should Write permissions be enabled for this SAS?
        """
elif False:
    GetAccountBlobContainerSASPermissionsArgsDict: TypeAlias = Mapping[str, Any]

@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?
               
               Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/create-service-sas)
               for additional details on the fields above.
        :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?

        Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/create-service-sas)
        for additional details on the fields above.
        """
        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)


if not MYPY:
    class GetAccountSASPermissionsArgsDict(TypedDict):
        add: bool
        """
        Should Add permissions be enabled for this SAS?
        """
        create: bool
        """
        Should Create permissions be enabled for this SAS?
        """
        delete: bool
        """
        Should Delete permissions be enabled for this SAS?
        """
        filter: bool
        """
        Should Filter by Index Tags permissions be enabled for this SAS?

        Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/constructing-an-account-sas)
        for additional details on the fields above.
        """
        list: bool
        """
        Should List permissions be enabled for this SAS?
        """
        process: bool
        """
        Should Process permissions be enabled for this SAS?
        """
        read: bool
        """
        Should Read permissions be enabled for this SAS?
        """
        tag: bool
        """
        Should Get / Set Index Tags permissions be enabled for this SAS?
        """
        update: bool
        """
        Should Update permissions be enabled for this SAS?
        """
        write: bool
        """
        Should Write permissions be enabled for this SAS?
        """
elif False:
    GetAccountSASPermissionsArgsDict: TypeAlias = Mapping[str, Any]

@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?
               
               Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/constructing-an-account-sas)
               for additional details on the fields above.
        :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?

        Refer to the [SAS creation reference from Azure](https://docs.microsoft.com/rest/api/storageservices/constructing-an-account-sas)
        for additional details on the fields above.
        """
        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)


if not MYPY:
    class GetAccountSASResourceTypesArgsDict(TypedDict):
        container: bool
        """
        Should permission be granted to the container?
        """
        object: bool
        """
        Should permission be granted only to a specific object?
        """
        service: bool
        """
        Should permission be granted to the entire service?
        """
elif False:
    GetAccountSASResourceTypesArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class GetAccountSASServicesArgsDict(TypedDict):
        blob: bool
        """
        Should permission be granted to `blob` services within this storage account?
        """
        file: bool
        """
        Should permission be granted to `file` services within this storage account?
        """
        queue: bool
        """
        Should permission be granted to `queue` services within this storage account?
        """
        table: bool
        """
        Should permission be granted to `table` services within this storage account?
        """
elif False:
    GetAccountSASServicesArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class GetShareAclArgsDict(TypedDict):
        access_policies: Sequence['GetShareAclAccessPolicyArgsDict']
        """
        An `access_policy` block as defined below.
        """
        id: str
        """
        The ID which should be used for this Shared Identifier.
        """
elif False:
    GetShareAclArgsDict: TypeAlias = Mapping[str, Any]

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


if not MYPY:
    class GetShareAclAccessPolicyArgsDict(TypedDict):
        expiry: str
        """
        The time at which this Access Policy is valid until.
        """
        permissions: 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).
        """
        start: str
        """
        The time at which this Access Policy is valid from.
        """
elif False:
    GetShareAclAccessPolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetShareAclAccessPolicyArgs:
    def __init__(__self__, *,
                 expiry: str,
                 permissions: str,
                 start: str):
        """
        :param str expiry: The time at which this Access Policy is valid until.
        :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 is valid from.
        """
        pulumi.set(__self__, "expiry", expiry)
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def expiry(self) -> str:
        """
        The time at which this Access Policy is valid until.
        """
        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 is valid from.
        """
        return pulumi.get(self, "start")

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


