pulumi-azure-native 2.86.0a1738343576__py3-none-any.whl → 2.87.0__py3-none-any.whl

pulumi_azure_native/storagecache/v20240701/outputs.py

@@ -0,0 +1,2735 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** 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
+from . import outputs
+from ._enums import *
+
+__all__ = [
+    'AmlFilesystemArchiveResponse',
+    'AmlFilesystemArchiveResponseStatus',
+    'AmlFilesystemClientInfoResponse',
+    'AmlFilesystemContainerStorageInterfaceResponse',
+    'AmlFilesystemEncryptionSettingsResponse',
+    'AmlFilesystemHealthResponse',
+    'AmlFilesystemHsmSettingsResponse',
+    'AmlFilesystemIdentityResponse',
+    'AmlFilesystemResponseHsm',
+    'AmlFilesystemResponseMaintenanceWindow',
+    'AmlFilesystemRootSquashSettingsResponse',
+    'BlobNfsTargetResponse',
+    'CacheActiveDirectorySettingsResponse',
+    'CacheActiveDirectorySettingsResponseCredentials',
+    'CacheDirectorySettingsResponse',
+    'CacheEncryptionSettingsResponse',
+    'CacheHealthResponse',
+    'CacheIdentityResponse',
+    'CacheIdentityResponseUserAssignedIdentities',
+    'CacheNetworkSettingsResponse',
+    'CacheResponseSku',
+    'CacheSecuritySettingsResponse',
+    'CacheUpgradeSettingsResponse',
+    'CacheUpgradeStatusResponse',
+    'CacheUsernameDownloadSettingsResponse',
+    'CacheUsernameDownloadSettingsResponseCredentials',
+    'ClfsTargetResponse',
+    'ConditionResponse',
+    'KeyVaultKeyReferenceResponse',
+    'KeyVaultKeyReferenceResponseSourceVault',
+    'NamespaceJunctionResponse',
+    'Nfs3TargetResponse',
+    'NfsAccessPolicyResponse',
+    'NfsAccessRuleResponse',
+    'PrimingJobResponse',
+    'SkuNameResponse',
+    'StorageTargetSpaceAllocationResponse',
+    'SystemDataResponse',
+    'UnknownTargetResponse',
+    'UserAssignedIdentitiesResponseUserAssignedIdentities',
+]
+
+@pulumi.output_type
+class AmlFilesystemArchiveResponse(dict):
+    """
+    Information about the AML file system archive
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "filesystemPath":
+            suggest = "filesystem_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemArchiveResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemArchiveResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemArchiveResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 filesystem_path: str,
+                 status: 'outputs.AmlFilesystemArchiveResponseStatus'):
+        """
+        Information about the AML file system archive
+        :param str filesystem_path: Lustre file system path to archive relative to the file system root.  Specify '/' to archive all modified data.
+        :param 'AmlFilesystemArchiveResponseStatus' status: The status of the archive
+        """
+        pulumi.set(__self__, "filesystem_path", filesystem_path)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="filesystemPath")
+    def filesystem_path(self) -> str:
+        """
+        Lustre file system path to archive relative to the file system root.  Specify '/' to archive all modified data.
+        """
+        return pulumi.get(self, "filesystem_path")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.AmlFilesystemArchiveResponseStatus':
+        """
+        The status of the archive
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class AmlFilesystemArchiveResponseStatus(dict):
+    """
+    The status of the archive
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorCode":
+            suggest = "error_code"
+        elif key == "errorMessage":
+            suggest = "error_message"
+        elif key == "lastCompletionTime":
+            suggest = "last_completion_time"
+        elif key == "lastStartedTime":
+            suggest = "last_started_time"
+        elif key == "percentComplete":
+            suggest = "percent_complete"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemArchiveResponseStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemArchiveResponseStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemArchiveResponseStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error_code: str,
+                 error_message: str,
+                 last_completion_time: str,
+                 last_started_time: str,
+                 percent_complete: int,
+                 state: str):
+        """
+        The status of the archive
+        :param str error_code: Server-defined error code for the archive operation
+        :param str error_message: Server-defined error message for the archive operation
+        :param str last_completion_time: The time of the last completed archive operation
+        :param str last_started_time: The time the latest archive operation started
+        :param int percent_complete: The completion percentage of the archive operation
+        :param str state: The state of the archive operation
+        """
+        pulumi.set(__self__, "error_code", error_code)
+        pulumi.set(__self__, "error_message", error_message)
+        pulumi.set(__self__, "last_completion_time", last_completion_time)
+        pulumi.set(__self__, "last_started_time", last_started_time)
+        pulumi.set(__self__, "percent_complete", percent_complete)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter(name="errorCode")
+    def error_code(self) -> str:
+        """
+        Server-defined error code for the archive operation
+        """
+        return pulumi.get(self, "error_code")
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> str:
+        """
+        Server-defined error message for the archive operation
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter(name="lastCompletionTime")
+    def last_completion_time(self) -> str:
+        """
+        The time of the last completed archive operation
+        """
+        return pulumi.get(self, "last_completion_time")
+
+    @property
+    @pulumi.getter(name="lastStartedTime")
+    def last_started_time(self) -> str:
+        """
+        The time the latest archive operation started
+        """
+        return pulumi.get(self, "last_started_time")
+
+    @property
+    @pulumi.getter(name="percentComplete")
+    def percent_complete(self) -> int:
+        """
+        The completion percentage of the archive operation
+        """
+        return pulumi.get(self, "percent_complete")
+
+    @property
+    @pulumi.getter
+    def state(self) -> str:
+        """
+        The state of the archive operation
+        """
+        return pulumi.get(self, "state")
+
+
+@pulumi.output_type
+class AmlFilesystemClientInfoResponse(dict):
+    """
+    AML file system client information
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "containerStorageInterface":
+            suggest = "container_storage_interface"
+        elif key == "lustreVersion":
+            suggest = "lustre_version"
+        elif key == "mgsAddress":
+            suggest = "mgs_address"
+        elif key == "mountCommand":
+            suggest = "mount_command"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemClientInfoResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemClientInfoResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemClientInfoResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 container_storage_interface: 'outputs.AmlFilesystemContainerStorageInterfaceResponse',
+                 lustre_version: str,
+                 mgs_address: str,
+                 mount_command: str):
+        """
+        AML file system client information
+        :param 'AmlFilesystemContainerStorageInterfaceResponse' container_storage_interface: Container Storage Interface information for the AML file system.
+        :param str lustre_version: The version of Lustre running in the AML file system
+        :param str mgs_address: The IPv4 address used by clients to mount the AML file system's Lustre Management Service (MGS).
+        :param str mount_command: Recommended command to mount the AML file system
+        """
+        pulumi.set(__self__, "container_storage_interface", container_storage_interface)
+        pulumi.set(__self__, "lustre_version", lustre_version)
+        pulumi.set(__self__, "mgs_address", mgs_address)
+        pulumi.set(__self__, "mount_command", mount_command)
+
+    @property
+    @pulumi.getter(name="containerStorageInterface")
+    def container_storage_interface(self) -> 'outputs.AmlFilesystemContainerStorageInterfaceResponse':
+        """
+        Container Storage Interface information for the AML file system.
+        """
+        return pulumi.get(self, "container_storage_interface")
+
+    @property
+    @pulumi.getter(name="lustreVersion")
+    def lustre_version(self) -> str:
+        """
+        The version of Lustre running in the AML file system
+        """
+        return pulumi.get(self, "lustre_version")
+
+    @property
+    @pulumi.getter(name="mgsAddress")
+    def mgs_address(self) -> str:
+        """
+        The IPv4 address used by clients to mount the AML file system's Lustre Management Service (MGS).
+        """
+        return pulumi.get(self, "mgs_address")
+
+    @property
+    @pulumi.getter(name="mountCommand")
+    def mount_command(self) -> str:
+        """
+        Recommended command to mount the AML file system
+        """
+        return pulumi.get(self, "mount_command")
+
+
+@pulumi.output_type
+class AmlFilesystemContainerStorageInterfaceResponse(dict):
+    """
+    AML file system container storage interface information
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "persistentVolume":
+            suggest = "persistent_volume"
+        elif key == "persistentVolumeClaim":
+            suggest = "persistent_volume_claim"
+        elif key == "storageClass":
+            suggest = "storage_class"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemContainerStorageInterfaceResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemContainerStorageInterfaceResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemContainerStorageInterfaceResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 persistent_volume: str,
+                 persistent_volume_claim: str,
+                 storage_class: str):
+        """
+        AML file system container storage interface information
+        :param str persistent_volume: Recommended AKS Persistent Volume for the CSI driver, in Base64 encoded YAML
+        :param str persistent_volume_claim: Recommended AKS Persistent Volume Claim for the CSI driver, in Base64 encoded YAML
+        :param str storage_class: Recommended AKS Storage Class for the CSI driver, in Base64 encoded YAML
+        """
+        pulumi.set(__self__, "persistent_volume", persistent_volume)
+        pulumi.set(__self__, "persistent_volume_claim", persistent_volume_claim)
+        pulumi.set(__self__, "storage_class", storage_class)
+
+    @property
+    @pulumi.getter(name="persistentVolume")
+    def persistent_volume(self) -> str:
+        """
+        Recommended AKS Persistent Volume for the CSI driver, in Base64 encoded YAML
+        """
+        return pulumi.get(self, "persistent_volume")
+
+    @property
+    @pulumi.getter(name="persistentVolumeClaim")
+    def persistent_volume_claim(self) -> str:
+        """
+        Recommended AKS Persistent Volume Claim for the CSI driver, in Base64 encoded YAML
+        """
+        return pulumi.get(self, "persistent_volume_claim")
+
+    @property
+    @pulumi.getter(name="storageClass")
+    def storage_class(self) -> str:
+        """
+        Recommended AKS Storage Class for the CSI driver, in Base64 encoded YAML
+        """
+        return pulumi.get(self, "storage_class")
+
+
+@pulumi.output_type
+class AmlFilesystemEncryptionSettingsResponse(dict):
+    """
+    AML file system encryption settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyEncryptionKey":
+            suggest = "key_encryption_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemEncryptionSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemEncryptionSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemEncryptionSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_encryption_key: Optional['outputs.KeyVaultKeyReferenceResponse'] = None):
+        """
+        AML file system encryption settings.
+        :param 'KeyVaultKeyReferenceResponse' key_encryption_key: Specifies the location of the encryption key in Key Vault.
+        """
+        if key_encryption_key is not None:
+            pulumi.set(__self__, "key_encryption_key", key_encryption_key)
+
+    @property
+    @pulumi.getter(name="keyEncryptionKey")
+    def key_encryption_key(self) -> Optional['outputs.KeyVaultKeyReferenceResponse']:
+        """
+        Specifies the location of the encryption key in Key Vault.
+        """
+        return pulumi.get(self, "key_encryption_key")
+
+
+@pulumi.output_type
+class AmlFilesystemHealthResponse(dict):
+    """
+    An indication of AML file system health. Gives more information about health than just that related to provisioning.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "statusCode":
+            suggest = "status_code"
+        elif key == "statusDescription":
+            suggest = "status_description"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemHealthResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemHealthResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemHealthResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 state: Optional[str] = None,
+                 status_code: Optional[str] = None,
+                 status_description: Optional[str] = None):
+        """
+        An indication of AML file system health. Gives more information about health than just that related to provisioning.
+        :param str state: List of AML file system health states.
+        :param str status_code: Server-defined error code for the AML file system health
+        :param str status_description: Describes the health state.
+        """
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+        if status_code is not None:
+            pulumi.set(__self__, "status_code", status_code)
+        if status_description is not None:
+            pulumi.set(__self__, "status_description", status_description)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[str]:
+        """
+        List of AML file system health states.
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="statusCode")
+    def status_code(self) -> Optional[str]:
+        """
+        Server-defined error code for the AML file system health
+        """
+        return pulumi.get(self, "status_code")
+
+    @property
+    @pulumi.getter(name="statusDescription")
+    def status_description(self) -> Optional[str]:
+        """
+        Describes the health state.
+        """
+        return pulumi.get(self, "status_description")
+
+
+@pulumi.output_type
+class AmlFilesystemHsmSettingsResponse(dict):
+    """
+    AML file system HSM settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "loggingContainer":
+            suggest = "logging_container"
+        elif key == "importPrefix":
+            suggest = "import_prefix"
+        elif key == "importPrefixesInitial":
+            suggest = "import_prefixes_initial"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemHsmSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemHsmSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemHsmSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 container: str,
+                 logging_container: str,
+                 import_prefix: Optional[str] = None,
+                 import_prefixes_initial: Optional[Sequence[str]] = None):
+        """
+        AML file system HSM settings.
+        :param str container: Resource ID of storage container used for hydrating the namespace and archiving from the namespace. The resource provider must have permission to create SAS tokens on the storage account.
+        :param str logging_container: Resource ID of storage container used for logging events and errors.  Must be a separate container in the same storage account as the hydration and archive container. The resource provider must have permission to create SAS tokens on the storage account.
+        :param str import_prefix: Only blobs in the non-logging container that start with this path/prefix get imported into the cluster namespace. This is only used during initial creation of the AML file system. It automatically creates an import job resource that can be deleted.
+        :param Sequence[str] import_prefixes_initial: Only blobs in the non-logging container that start with one of the paths/prefixes in this array get imported into the cluster namespace. This is only used during initial creation of the AML file system and has '/' as the default value. It automatically creates an import job resource that can be deleted.
+        """
+        pulumi.set(__self__, "container", container)
+        pulumi.set(__self__, "logging_container", logging_container)
+        if import_prefix is None:
+            import_prefix = '/'
+        if import_prefix is not None:
+            pulumi.set(__self__, "import_prefix", import_prefix)
+        if import_prefixes_initial is not None:
+            pulumi.set(__self__, "import_prefixes_initial", import_prefixes_initial)
+
+    @property
+    @pulumi.getter
+    def container(self) -> str:
+        """
+        Resource ID of storage container used for hydrating the namespace and archiving from the namespace. The resource provider must have permission to create SAS tokens on the storage account.
+        """
+        return pulumi.get(self, "container")
+
+    @property
+    @pulumi.getter(name="loggingContainer")
+    def logging_container(self) -> str:
+        """
+        Resource ID of storage container used for logging events and errors.  Must be a separate container in the same storage account as the hydration and archive container. The resource provider must have permission to create SAS tokens on the storage account.
+        """
+        return pulumi.get(self, "logging_container")
+
+    @property
+    @pulumi.getter(name="importPrefix")
+    def import_prefix(self) -> Optional[str]:
+        """
+        Only blobs in the non-logging container that start with this path/prefix get imported into the cluster namespace. This is only used during initial creation of the AML file system. It automatically creates an import job resource that can be deleted.
+        """
+        return pulumi.get(self, "import_prefix")
+
+    @property
+    @pulumi.getter(name="importPrefixesInitial")
+    def import_prefixes_initial(self) -> Optional[Sequence[str]]:
+        """
+        Only blobs in the non-logging container that start with one of the paths/prefixes in this array get imported into the cluster namespace. This is only used during initial creation of the AML file system and has '/' as the default value. It automatically creates an import job resource that can be deleted.
+        """
+        return pulumi.get(self, "import_prefixes_initial")
+
+
+@pulumi.output_type
+class AmlFilesystemIdentityResponse(dict):
+    """
+    Managed Identity properties.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: str,
+                 tenant_id: str,
+                 type: Optional[str] = None,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentitiesResponseUserAssignedIdentities']] = None):
+        """
+        Managed Identity properties.
+        :param str principal_id: The principal ID for the user-assigned identity of the resource.
+        :param str tenant_id: The tenant ID associated with the resource.
+        :param str type: The type of identity used for the resource.
+        :param Mapping[str, 'UserAssignedIdentitiesResponseUserAssignedIdentities'] user_assigned_identities: A dictionary where each key is a user assigned identity resource ID, and each key's value is an empty dictionary.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID for the user-assigned identity of the resource.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> str:
+        """
+        The tenant ID associated with the resource.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of identity used for the resource.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentitiesResponseUserAssignedIdentities']]:
+        """
+        A dictionary where each key is a user assigned identity resource ID, and each key's value is an empty dictionary.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
+@pulumi.output_type
+class AmlFilesystemResponseHsm(dict):
+    """
+    Hydration and archive settings and status
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "archiveStatus":
+            suggest = "archive_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemResponseHsm. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemResponseHsm.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemResponseHsm.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 archive_status: Sequence['outputs.AmlFilesystemArchiveResponse'],
+                 settings: Optional['outputs.AmlFilesystemHsmSettingsResponse'] = None):
+        """
+        Hydration and archive settings and status
+        :param Sequence['AmlFilesystemArchiveResponse'] archive_status: Archive status
+        :param 'AmlFilesystemHsmSettingsResponse' settings: Specifies HSM settings of the AML file system.
+        """
+        pulumi.set(__self__, "archive_status", archive_status)
+        if settings is not None:
+            pulumi.set(__self__, "settings", settings)
+
+    @property
+    @pulumi.getter(name="archiveStatus")
+    def archive_status(self) -> Sequence['outputs.AmlFilesystemArchiveResponse']:
+        """
+        Archive status
+        """
+        return pulumi.get(self, "archive_status")
+
+    @property
+    @pulumi.getter
+    def settings(self) -> Optional['outputs.AmlFilesystemHsmSettingsResponse']:
+        """
+        Specifies HSM settings of the AML file system.
+        """
+        return pulumi.get(self, "settings")
+
+
+@pulumi.output_type
+class AmlFilesystemResponseMaintenanceWindow(dict):
+    """
+    Start time of a 30-minute weekly maintenance window.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dayOfWeek":
+            suggest = "day_of_week"
+        elif key == "timeOfDayUTC":
+            suggest = "time_of_day_utc"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemResponseMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemResponseMaintenanceWindow.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemResponseMaintenanceWindow.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 day_of_week: Optional[str] = None,
+                 time_of_day_utc: Optional[str] = None):
+        """
+        Start time of a 30-minute weekly maintenance window.
+        :param str day_of_week: Day of the week on which the maintenance window will occur.
+        :param str time_of_day_utc: The time of day (in UTC) to start the maintenance window.
+        """
+        if day_of_week is not None:
+            pulumi.set(__self__, "day_of_week", day_of_week)
+        if time_of_day_utc is not None:
+            pulumi.set(__self__, "time_of_day_utc", time_of_day_utc)
+
+    @property
+    @pulumi.getter(name="dayOfWeek")
+    def day_of_week(self) -> Optional[str]:
+        """
+        Day of the week on which the maintenance window will occur.
+        """
+        return pulumi.get(self, "day_of_week")
+
+    @property
+    @pulumi.getter(name="timeOfDayUTC")
+    def time_of_day_utc(self) -> Optional[str]:
+        """
+        The time of day (in UTC) to start the maintenance window.
+        """
+        return pulumi.get(self, "time_of_day_utc")
+
+
+@pulumi.output_type
+class AmlFilesystemRootSquashSettingsResponse(dict):
+    """
+    AML file system squash settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "noSquashNidLists":
+            suggest = "no_squash_nid_lists"
+        elif key == "squashGID":
+            suggest = "squash_gid"
+        elif key == "squashUID":
+            suggest = "squash_uid"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AmlFilesystemRootSquashSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AmlFilesystemRootSquashSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AmlFilesystemRootSquashSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 status: str,
+                 mode: Optional[str] = None,
+                 no_squash_nid_lists: Optional[str] = None,
+                 squash_gid: Optional[float] = None,
+                 squash_uid: Optional[float] = None):
+        """
+        AML file system squash settings.
+        :param str status: AML file system squash status.
+        :param str mode: Squash mode of the AML file system. 'All': User and Group IDs on files will be squashed to the provided values for all users on non-trusted systems. 'RootOnly': User and Group IDs on files will be squashed to provided values for solely the root user on non-trusted systems. 'None': No squashing of User and Group IDs is performed for any users on any systems.
+        :param str no_squash_nid_lists: Semicolon separated NID IP Address list(s) to be added to the TrustedSystems.
+        :param float squash_gid: Group ID to squash to.
+        :param float squash_uid: User ID to squash to.
+        """
+        pulumi.set(__self__, "status", status)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+        if no_squash_nid_lists is not None:
+            pulumi.set(__self__, "no_squash_nid_lists", no_squash_nid_lists)
+        if squash_gid is not None:
+            pulumi.set(__self__, "squash_gid", squash_gid)
+        if squash_uid is not None:
+            pulumi.set(__self__, "squash_uid", squash_uid)
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        AML file system squash status.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[str]:
+        """
+        Squash mode of the AML file system. 'All': User and Group IDs on files will be squashed to the provided values for all users on non-trusted systems. 'RootOnly': User and Group IDs on files will be squashed to provided values for solely the root user on non-trusted systems. 'None': No squashing of User and Group IDs is performed for any users on any systems.
+        """
+        return pulumi.get(self, "mode")
+
+    @property
+    @pulumi.getter(name="noSquashNidLists")
+    def no_squash_nid_lists(self) -> Optional[str]:
+        """
+        Semicolon separated NID IP Address list(s) to be added to the TrustedSystems.
+        """
+        return pulumi.get(self, "no_squash_nid_lists")
+
+    @property
+    @pulumi.getter(name="squashGID")
+    def squash_gid(self) -> Optional[float]:
+        """
+        Group ID to squash to.
+        """
+        return pulumi.get(self, "squash_gid")
+
+    @property
+    @pulumi.getter(name="squashUID")
+    def squash_uid(self) -> Optional[float]:
+        """
+        User ID to squash to.
+        """
+        return pulumi.get(self, "squash_uid")
+
+
+@pulumi.output_type
+class BlobNfsTargetResponse(dict):
+    """
+    Properties pertaining to the BlobNfsTarget.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "usageModel":
+            suggest = "usage_model"
+        elif key == "verificationTimer":
+            suggest = "verification_timer"
+        elif key == "writeBackTimer":
+            suggest = "write_back_timer"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BlobNfsTargetResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BlobNfsTargetResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BlobNfsTargetResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 target: Optional[str] = None,
+                 usage_model: Optional[str] = None,
+                 verification_timer: Optional[int] = None,
+                 write_back_timer: Optional[int] = None):
+        """
+        Properties pertaining to the BlobNfsTarget.
+        :param str target: Resource ID of the storage container.
+        :param str usage_model: Identifies the StorageCache usage model to be used for this storage target.
+        :param int verification_timer: Amount of time (in seconds) the cache waits before it checks the back-end storage for file updates.
+        :param int write_back_timer: Amount of time (in seconds) the cache waits after the last file change before it copies the changed file to back-end storage.
+        """
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+        if usage_model is not None:
+            pulumi.set(__self__, "usage_model", usage_model)
+        if verification_timer is not None:
+            pulumi.set(__self__, "verification_timer", verification_timer)
+        if write_back_timer is not None:
+            pulumi.set(__self__, "write_back_timer", write_back_timer)
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional[str]:
+        """
+        Resource ID of the storage container.
+        """
+        return pulumi.get(self, "target")
+
+    @property
+    @pulumi.getter(name="usageModel")
+    def usage_model(self) -> Optional[str]:
+        """
+        Identifies the StorageCache usage model to be used for this storage target.
+        """
+        return pulumi.get(self, "usage_model")
+
+    @property
+    @pulumi.getter(name="verificationTimer")
+    def verification_timer(self) -> Optional[int]:
+        """
+        Amount of time (in seconds) the cache waits before it checks the back-end storage for file updates.
+        """
+        return pulumi.get(self, "verification_timer")
+
+    @property
+    @pulumi.getter(name="writeBackTimer")
+    def write_back_timer(self) -> Optional[int]:
+        """
+        Amount of time (in seconds) the cache waits after the last file change before it copies the changed file to back-end storage.
+        """
+        return pulumi.get(self, "write_back_timer")
+
+
+@pulumi.output_type
+class CacheActiveDirectorySettingsResponse(dict):
+    """
+    Active Directory settings used to join a cache to a domain.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cacheNetBiosName":
+            suggest = "cache_net_bios_name"
+        elif key == "domainJoined":
+            suggest = "domain_joined"
+        elif key == "domainName":
+            suggest = "domain_name"
+        elif key == "domainNetBiosName":
+            suggest = "domain_net_bios_name"
+        elif key == "primaryDnsIpAddress":
+            suggest = "primary_dns_ip_address"
+        elif key == "secondaryDnsIpAddress":
+            suggest = "secondary_dns_ip_address"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheActiveDirectorySettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheActiveDirectorySettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheActiveDirectorySettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cache_net_bios_name: str,
+                 domain_joined: str,
+                 domain_name: str,
+                 domain_net_bios_name: str,
+                 primary_dns_ip_address: str,
+                 credentials: Optional['outputs.CacheActiveDirectorySettingsResponseCredentials'] = None,
+                 secondary_dns_ip_address: Optional[str] = None):
+        """
+        Active Directory settings used to join a cache to a domain.
+        :param str cache_net_bios_name: The NetBIOS name to assign to the HPC Cache when it joins the Active Directory domain as a server. Length must 1-15 characters from the class [-0-9a-zA-Z].
+        :param str domain_joined: True if the HPC Cache is joined to the Active Directory domain.
+        :param str domain_name: The fully qualified domain name of the Active Directory domain controller.
+        :param str domain_net_bios_name: The Active Directory domain's NetBIOS name.
+        :param str primary_dns_ip_address: Primary DNS IP address used to resolve the Active Directory domain controller's fully qualified domain name.
+        :param 'CacheActiveDirectorySettingsResponseCredentials' credentials: Active Directory admin credentials used to join the HPC Cache to a domain.
+        :param str secondary_dns_ip_address: Secondary DNS IP address used to resolve the Active Directory domain controller's fully qualified domain name.
+        """
+        pulumi.set(__self__, "cache_net_bios_name", cache_net_bios_name)
+        pulumi.set(__self__, "domain_joined", domain_joined)
+        pulumi.set(__self__, "domain_name", domain_name)
+        pulumi.set(__self__, "domain_net_bios_name", domain_net_bios_name)
+        pulumi.set(__self__, "primary_dns_ip_address", primary_dns_ip_address)
+        if credentials is not None:
+            pulumi.set(__self__, "credentials", credentials)
+        if secondary_dns_ip_address is not None:
+            pulumi.set(__self__, "secondary_dns_ip_address", secondary_dns_ip_address)
+
+    @property
+    @pulumi.getter(name="cacheNetBiosName")
+    def cache_net_bios_name(self) -> str:
+        """
+        The NetBIOS name to assign to the HPC Cache when it joins the Active Directory domain as a server. Length must 1-15 characters from the class [-0-9a-zA-Z].
+        """
+        return pulumi.get(self, "cache_net_bios_name")
+
+    @property
+    @pulumi.getter(name="domainJoined")
+    def domain_joined(self) -> str:
+        """
+        True if the HPC Cache is joined to the Active Directory domain.
+        """
+        return pulumi.get(self, "domain_joined")
+
+    @property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> str:
+        """
+        The fully qualified domain name of the Active Directory domain controller.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @property
+    @pulumi.getter(name="domainNetBiosName")
+    def domain_net_bios_name(self) -> str:
+        """
+        The Active Directory domain's NetBIOS name.
+        """
+        return pulumi.get(self, "domain_net_bios_name")
+
+    @property
+    @pulumi.getter(name="primaryDnsIpAddress")
+    def primary_dns_ip_address(self) -> str:
+        """
+        Primary DNS IP address used to resolve the Active Directory domain controller's fully qualified domain name.
+        """
+        return pulumi.get(self, "primary_dns_ip_address")
+
+    @property
+    @pulumi.getter
+    def credentials(self) -> Optional['outputs.CacheActiveDirectorySettingsResponseCredentials']:
+        """
+        Active Directory admin credentials used to join the HPC Cache to a domain.
+        """
+        return pulumi.get(self, "credentials")
+
+    @property
+    @pulumi.getter(name="secondaryDnsIpAddress")
+    def secondary_dns_ip_address(self) -> Optional[str]:
+        """
+        Secondary DNS IP address used to resolve the Active Directory domain controller's fully qualified domain name.
+        """
+        return pulumi.get(self, "secondary_dns_ip_address")
+
+
+@pulumi.output_type
+class CacheActiveDirectorySettingsResponseCredentials(dict):
+    """
+    Active Directory admin credentials used to join the HPC Cache to a domain.
+    """
+    def __init__(__self__, *,
+                 username: str,
+                 password: Optional[str] = None):
+        """
+        Active Directory admin credentials used to join the HPC Cache to a domain.
+        :param str username: Username of the Active Directory domain administrator. This value is stored encrypted and not returned on response.
+        :param str password: Plain text password of the Active Directory domain administrator. This value is stored encrypted and not returned on response.
+        """
+        pulumi.set(__self__, "username", username)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+
+    @property
+    @pulumi.getter
+    def username(self) -> str:
+        """
+        Username of the Active Directory domain administrator. This value is stored encrypted and not returned on response.
+        """
+        return pulumi.get(self, "username")
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[str]:
+        """
+        Plain text password of the Active Directory domain administrator. This value is stored encrypted and not returned on response.
+        """
+        return pulumi.get(self, "password")
+
+
+@pulumi.output_type
+class CacheDirectorySettingsResponse(dict):
+    """
+    Cache Directory Services settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "activeDirectory":
+            suggest = "active_directory"
+        elif key == "usernameDownload":
+            suggest = "username_download"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheDirectorySettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheDirectorySettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheDirectorySettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 active_directory: Optional['outputs.CacheActiveDirectorySettingsResponse'] = None,
+                 username_download: Optional['outputs.CacheUsernameDownloadSettingsResponse'] = None):
+        """
+        Cache Directory Services settings.
+        :param 'CacheActiveDirectorySettingsResponse' active_directory: Specifies settings for joining the HPC Cache to an Active Directory domain.
+        :param 'CacheUsernameDownloadSettingsResponse' username_download: Specifies settings for Extended Groups. Extended Groups allows users to be members of more than 16 groups.
+        """
+        if active_directory is not None:
+            pulumi.set(__self__, "active_directory", active_directory)
+        if username_download is not None:
+            pulumi.set(__self__, "username_download", username_download)
+
+    @property
+    @pulumi.getter(name="activeDirectory")
+    def active_directory(self) -> Optional['outputs.CacheActiveDirectorySettingsResponse']:
+        """
+        Specifies settings for joining the HPC Cache to an Active Directory domain.
+        """
+        return pulumi.get(self, "active_directory")
+
+    @property
+    @pulumi.getter(name="usernameDownload")
+    def username_download(self) -> Optional['outputs.CacheUsernameDownloadSettingsResponse']:
+        """
+        Specifies settings for Extended Groups. Extended Groups allows users to be members of more than 16 groups.
+        """
+        return pulumi.get(self, "username_download")
+
+
+@pulumi.output_type
+class CacheEncryptionSettingsResponse(dict):
+    """
+    Cache encryption settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyEncryptionKey":
+            suggest = "key_encryption_key"
+        elif key == "rotationToLatestKeyVersionEnabled":
+            suggest = "rotation_to_latest_key_version_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheEncryptionSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheEncryptionSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheEncryptionSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_encryption_key: Optional['outputs.KeyVaultKeyReferenceResponse'] = None,
+                 rotation_to_latest_key_version_enabled: Optional[bool] = None):
+        """
+        Cache encryption settings.
+        :param 'KeyVaultKeyReferenceResponse' key_encryption_key: Specifies the location of the key encryption key in key vault.
+        :param bool rotation_to_latest_key_version_enabled: Specifies whether the service will automatically rotate to the newest version of the key in the key vault.
+        """
+        if key_encryption_key is not None:
+            pulumi.set(__self__, "key_encryption_key", key_encryption_key)
+        if rotation_to_latest_key_version_enabled is not None:
+            pulumi.set(__self__, "rotation_to_latest_key_version_enabled", rotation_to_latest_key_version_enabled)
+
+    @property
+    @pulumi.getter(name="keyEncryptionKey")
+    def key_encryption_key(self) -> Optional['outputs.KeyVaultKeyReferenceResponse']:
+        """
+        Specifies the location of the key encryption key in key vault.
+        """
+        return pulumi.get(self, "key_encryption_key")
+
+    @property
+    @pulumi.getter(name="rotationToLatestKeyVersionEnabled")
+    def rotation_to_latest_key_version_enabled(self) -> Optional[bool]:
+        """
+        Specifies whether the service will automatically rotate to the newest version of the key in the key vault.
+        """
+        return pulumi.get(self, "rotation_to_latest_key_version_enabled")
+
+
+@pulumi.output_type
+class CacheHealthResponse(dict):
+    """
+    An indication of cache health. Gives more information about health than just that related to provisioning.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "statusDescription":
+            suggest = "status_description"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheHealthResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheHealthResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheHealthResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 conditions: Sequence['outputs.ConditionResponse'],
+                 state: Optional[str] = None,
+                 status_description: Optional[str] = None):
+        """
+        An indication of cache health. Gives more information about health than just that related to provisioning.
+        :param Sequence['ConditionResponse'] conditions: Outstanding conditions that need to be investigated and resolved.
+        :param str state: List of cache health states. Down is when the cluster is not responding.  Degraded is when its functioning but has some alerts. Transitioning when it is creating or deleting. Unknown will be returned in old api versions when a new value is added in future versions. WaitingForKey is when the create is waiting for the system assigned identity to be given access to the encryption key in the encryption settings.
+        :param str status_description: Describes explanation of state.
+        """
+        pulumi.set(__self__, "conditions", conditions)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+        if status_description is not None:
+            pulumi.set(__self__, "status_description", status_description)
+
+    @property
+    @pulumi.getter
+    def conditions(self) -> Sequence['outputs.ConditionResponse']:
+        """
+        Outstanding conditions that need to be investigated and resolved.
+        """
+        return pulumi.get(self, "conditions")
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[str]:
+        """
+        List of cache health states. Down is when the cluster is not responding.  Degraded is when its functioning but has some alerts. Transitioning when it is creating or deleting. Unknown will be returned in old api versions when a new value is added in future versions. WaitingForKey is when the create is waiting for the system assigned identity to be given access to the encryption key in the encryption settings.
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="statusDescription")
+    def status_description(self) -> Optional[str]:
+        """
+        Describes explanation of state.
+        """
+        return pulumi.get(self, "status_description")
+
+
+@pulumi.output_type
+class CacheIdentityResponse(dict):
+    """
+    Cache identity properties.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: str,
+                 tenant_id: str,
+                 type: Optional[str] = None,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.CacheIdentityResponseUserAssignedIdentities']] = None):
+        """
+        Cache identity properties.
+        :param str principal_id: The principal ID for the system-assigned identity of the cache.
+        :param str tenant_id: The tenant ID associated with the cache.
+        :param str type: The type of identity used for the cache
+        :param Mapping[str, 'CacheIdentityResponseUserAssignedIdentities'] user_assigned_identities: A dictionary where each key is a user assigned identity resource ID, and each key's value is an empty dictionary.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID for the system-assigned identity of the cache.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> str:
+        """
+        The tenant ID associated with the cache.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of identity used for the cache
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.CacheIdentityResponseUserAssignedIdentities']]:
+        """
+        A dictionary where each key is a user assigned identity resource ID, and each key's value is an empty dictionary.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
+@pulumi.output_type
+class CacheIdentityResponseUserAssignedIdentities(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "principalId":
+            suggest = "principal_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheIdentityResponseUserAssignedIdentities. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheIdentityResponseUserAssignedIdentities.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheIdentityResponseUserAssignedIdentities.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: str,
+                 principal_id: str):
+        """
+        :param str client_id: The client ID of the user-assigned identity.
+        :param str principal_id: The principal ID of the user-assigned identity.
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "principal_id", principal_id)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> str:
+        """
+        The client ID of the user-assigned identity.
+        """
+        return pulumi.get(self, "client_id")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID of the user-assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+
+@pulumi.output_type
+class CacheNetworkSettingsResponse(dict):
+    """
+    Cache network settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "utilityAddresses":
+            suggest = "utility_addresses"
+        elif key == "dnsSearchDomain":
+            suggest = "dns_search_domain"
+        elif key == "dnsServers":
+            suggest = "dns_servers"
+        elif key == "ntpServer":
+            suggest = "ntp_server"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheNetworkSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheNetworkSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheNetworkSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 utility_addresses: Sequence[str],
+                 dns_search_domain: Optional[str] = None,
+                 dns_servers: Optional[Sequence[str]] = None,
+                 mtu: Optional[int] = None,
+                 ntp_server: Optional[str] = None):
+        """
+        Cache network settings.
+        :param Sequence[str] utility_addresses: Array of additional IP addresses used by this cache.
+        :param str dns_search_domain: DNS search domain
+        :param Sequence[str] dns_servers: DNS servers for the cache to use.  It will be set from the network configuration if no value is provided.
+        :param int mtu: The IPv4 maximum transmission unit configured for the subnet.
+        :param str ntp_server: NTP server IP Address or FQDN for the cache to use. The default is time.windows.com.
+        """
+        pulumi.set(__self__, "utility_addresses", utility_addresses)
+        if dns_search_domain is not None:
+            pulumi.set(__self__, "dns_search_domain", dns_search_domain)
+        if dns_servers is not None:
+            pulumi.set(__self__, "dns_servers", dns_servers)
+        if mtu is None:
+            mtu = 1500
+        if mtu is not None:
+            pulumi.set(__self__, "mtu", mtu)
+        if ntp_server is None:
+            ntp_server = 'time.windows.com'
+        if ntp_server is not None:
+            pulumi.set(__self__, "ntp_server", ntp_server)
+
+    @property
+    @pulumi.getter(name="utilityAddresses")
+    def utility_addresses(self) -> Sequence[str]:
+        """
+        Array of additional IP addresses used by this cache.
+        """
+        return pulumi.get(self, "utility_addresses")
+
+    @property
+    @pulumi.getter(name="dnsSearchDomain")
+    def dns_search_domain(self) -> Optional[str]:
+        """
+        DNS search domain
+        """
+        return pulumi.get(self, "dns_search_domain")
+
+    @property
+    @pulumi.getter(name="dnsServers")
+    def dns_servers(self) -> Optional[Sequence[str]]:
+        """
+        DNS servers for the cache to use.  It will be set from the network configuration if no value is provided.
+        """
+        return pulumi.get(self, "dns_servers")
+
+    @property
+    @pulumi.getter
+    def mtu(self) -> Optional[int]:
+        """
+        The IPv4 maximum transmission unit configured for the subnet.
+        """
+        return pulumi.get(self, "mtu")
+
+    @property
+    @pulumi.getter(name="ntpServer")
+    def ntp_server(self) -> Optional[str]:
+        """
+        NTP server IP Address or FQDN for the cache to use. The default is time.windows.com.
+        """
+        return pulumi.get(self, "ntp_server")
+
+
+@pulumi.output_type
+class CacheResponseSku(dict):
+    """
+    SKU for the cache.
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None):
+        """
+        SKU for the cache.
+        :param str name: SKU name for this cache.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        SKU name for this cache.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class CacheSecuritySettingsResponse(dict):
+    """
+    Cache security settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessPolicies":
+            suggest = "access_policies"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheSecuritySettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheSecuritySettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheSecuritySettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_policies: Optional[Sequence['outputs.NfsAccessPolicyResponse']] = None):
+        """
+        Cache security settings.
+        :param Sequence['NfsAccessPolicyResponse'] access_policies: NFS access policies defined for this cache.
+        """
+        if access_policies is not None:
+            pulumi.set(__self__, "access_policies", access_policies)
+
+    @property
+    @pulumi.getter(name="accessPolicies")
+    def access_policies(self) -> Optional[Sequence['outputs.NfsAccessPolicyResponse']]:
+        """
+        NFS access policies defined for this cache.
+        """
+        return pulumi.get(self, "access_policies")
+
+
+@pulumi.output_type
+class CacheUpgradeSettingsResponse(dict):
+    """
+    Cache Upgrade Settings.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "scheduledTime":
+            suggest = "scheduled_time"
+        elif key == "upgradeScheduleEnabled":
+            suggest = "upgrade_schedule_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheUpgradeSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheUpgradeSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheUpgradeSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 scheduled_time: Optional[str] = None,
+                 upgrade_schedule_enabled: Optional[bool] = None):
+        """
+        Cache Upgrade Settings.
+        :param str scheduled_time: When upgradeScheduleEnabled is true, this field holds the user-chosen upgrade time. At the user-chosen time, the firmware update will automatically be installed on the cache.
+        :param bool upgrade_schedule_enabled: True if the user chooses to select an installation time between now and firmwareUpdateDeadline. Else the firmware will automatically be installed after firmwareUpdateDeadline if not triggered earlier via the upgrade operation.
+        """
+        if scheduled_time is not None:
+            pulumi.set(__self__, "scheduled_time", scheduled_time)
+        if upgrade_schedule_enabled is not None:
+            pulumi.set(__self__, "upgrade_schedule_enabled", upgrade_schedule_enabled)
+
+    @property
+    @pulumi.getter(name="scheduledTime")
+    def scheduled_time(self) -> Optional[str]:
+        """
+        When upgradeScheduleEnabled is true, this field holds the user-chosen upgrade time. At the user-chosen time, the firmware update will automatically be installed on the cache.
+        """
+        return pulumi.get(self, "scheduled_time")
+
+    @property
+    @pulumi.getter(name="upgradeScheduleEnabled")
+    def upgrade_schedule_enabled(self) -> Optional[bool]:
+        """
+        True if the user chooses to select an installation time between now and firmwareUpdateDeadline. Else the firmware will automatically be installed after firmwareUpdateDeadline if not triggered earlier via the upgrade operation.
+        """
+        return pulumi.get(self, "upgrade_schedule_enabled")
+
+
+@pulumi.output_type
+class CacheUpgradeStatusResponse(dict):
+    """
+    Properties describing the software upgrade state of the cache.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "currentFirmwareVersion":
+            suggest = "current_firmware_version"
+        elif key == "firmwareUpdateDeadline":
+            suggest = "firmware_update_deadline"
+        elif key == "firmwareUpdateStatus":
+            suggest = "firmware_update_status"
+        elif key == "lastFirmwareUpdate":
+            suggest = "last_firmware_update"
+        elif key == "pendingFirmwareVersion":
+            suggest = "pending_firmware_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheUpgradeStatusResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheUpgradeStatusResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheUpgradeStatusResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 current_firmware_version: str,
+                 firmware_update_deadline: str,
+                 firmware_update_status: str,
+                 last_firmware_update: str,
+                 pending_firmware_version: str):
+        """
+        Properties describing the software upgrade state of the cache.
+        :param str current_firmware_version: Version string of the firmware currently installed on this cache.
+        :param str firmware_update_deadline: Time at which the pending firmware update will automatically be installed on the cache.
+        :param str firmware_update_status: True if there is a firmware update ready to install on this cache. The firmware will automatically be installed after firmwareUpdateDeadline if not triggered earlier via the upgrade operation.
+        :param str last_firmware_update: Time of the last successful firmware update.
+        :param str pending_firmware_version: When firmwareUpdateAvailable is true, this field holds the version string for the update.
+        """
+        pulumi.set(__self__, "current_firmware_version", current_firmware_version)
+        pulumi.set(__self__, "firmware_update_deadline", firmware_update_deadline)
+        pulumi.set(__self__, "firmware_update_status", firmware_update_status)
+        pulumi.set(__self__, "last_firmware_update", last_firmware_update)
+        pulumi.set(__self__, "pending_firmware_version", pending_firmware_version)
+
+    @property
+    @pulumi.getter(name="currentFirmwareVersion")
+    def current_firmware_version(self) -> str:
+        """
+        Version string of the firmware currently installed on this cache.
+        """
+        return pulumi.get(self, "current_firmware_version")
+
+    @property
+    @pulumi.getter(name="firmwareUpdateDeadline")
+    def firmware_update_deadline(self) -> str:
+        """
+        Time at which the pending firmware update will automatically be installed on the cache.
+        """
+        return pulumi.get(self, "firmware_update_deadline")
+
+    @property
+    @pulumi.getter(name="firmwareUpdateStatus")
+    def firmware_update_status(self) -> str:
+        """
+        True if there is a firmware update ready to install on this cache. The firmware will automatically be installed after firmwareUpdateDeadline if not triggered earlier via the upgrade operation.
+        """
+        return pulumi.get(self, "firmware_update_status")
+
+    @property
+    @pulumi.getter(name="lastFirmwareUpdate")
+    def last_firmware_update(self) -> str:
+        """
+        Time of the last successful firmware update.
+        """
+        return pulumi.get(self, "last_firmware_update")
+
+    @property
+    @pulumi.getter(name="pendingFirmwareVersion")
+    def pending_firmware_version(self) -> str:
+        """
+        When firmwareUpdateAvailable is true, this field holds the version string for the update.
+        """
+        return pulumi.get(self, "pending_firmware_version")
+
+
+@pulumi.output_type
+class CacheUsernameDownloadSettingsResponse(dict):
+    """
+    Settings for Extended Groups username and group download.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "usernameDownloaded":
+            suggest = "username_downloaded"
+        elif key == "autoDownloadCertificate":
+            suggest = "auto_download_certificate"
+        elif key == "caCertificateURI":
+            suggest = "ca_certificate_uri"
+        elif key == "encryptLdapConnection":
+            suggest = "encrypt_ldap_connection"
+        elif key == "extendedGroups":
+            suggest = "extended_groups"
+        elif key == "groupFileURI":
+            suggest = "group_file_uri"
+        elif key == "ldapBaseDN":
+            suggest = "ldap_base_dn"
+        elif key == "ldapServer":
+            suggest = "ldap_server"
+        elif key == "requireValidCertificate":
+            suggest = "require_valid_certificate"
+        elif key == "userFileURI":
+            suggest = "user_file_uri"
+        elif key == "usernameSource":
+            suggest = "username_source"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheUsernameDownloadSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheUsernameDownloadSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheUsernameDownloadSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 username_downloaded: str,
+                 auto_download_certificate: Optional[bool] = None,
+                 ca_certificate_uri: Optional[str] = None,
+                 credentials: Optional['outputs.CacheUsernameDownloadSettingsResponseCredentials'] = None,
+                 encrypt_ldap_connection: Optional[bool] = None,
+                 extended_groups: Optional[bool] = None,
+                 group_file_uri: Optional[str] = None,
+                 ldap_base_dn: Optional[str] = None,
+                 ldap_server: Optional[str] = None,
+                 require_valid_certificate: Optional[bool] = None,
+                 user_file_uri: Optional[str] = None,
+                 username_source: Optional[str] = None):
+        """
+        Settings for Extended Groups username and group download.
+        :param str username_downloaded: Indicates whether or not the HPC Cache has performed the username download successfully.
+        :param bool auto_download_certificate: Determines if the certificate should be automatically downloaded. This applies to 'caCertificateURI' only if 'requireValidCertificate' is true.
+        :param str ca_certificate_uri: The URI of the CA certificate to validate the LDAP secure connection. This field must be populated when 'requireValidCertificate' is set to true.
+        :param 'CacheUsernameDownloadSettingsResponseCredentials' credentials: When present, these are the credentials for the secure LDAP connection.
+        :param bool encrypt_ldap_connection: Whether or not the LDAP connection should be encrypted.
+        :param bool extended_groups: Whether or not Extended Groups is enabled.
+        :param str group_file_uri: The URI of the file containing group information (in /etc/group file format). This field must be populated when 'usernameSource' is set to 'File'.
+        :param str ldap_base_dn: The base distinguished name for the LDAP domain.
+        :param str ldap_server: The fully qualified domain name or IP address of the LDAP server to use.
+        :param bool require_valid_certificate: Determines if the certificates must be validated by a certificate authority. When true, caCertificateURI must be provided.
+        :param str user_file_uri: The URI of the file containing user information (in /etc/passwd file format). This field must be populated when 'usernameSource' is set to 'File'.
+        :param str username_source: This setting determines how the cache gets username and group names for clients.
+        """
+        pulumi.set(__self__, "username_downloaded", username_downloaded)
+        if auto_download_certificate is None:
+            auto_download_certificate = False
+        if auto_download_certificate is not None:
+            pulumi.set(__self__, "auto_download_certificate", auto_download_certificate)
+        if ca_certificate_uri is not None:
+            pulumi.set(__self__, "ca_certificate_uri", ca_certificate_uri)
+        if credentials is not None:
+            pulumi.set(__self__, "credentials", credentials)
+        if encrypt_ldap_connection is None:
+            encrypt_ldap_connection = False
+        if encrypt_ldap_connection is not None:
+            pulumi.set(__self__, "encrypt_ldap_connection", encrypt_ldap_connection)
+        if extended_groups is not None:
+            pulumi.set(__self__, "extended_groups", extended_groups)
+        if group_file_uri is not None:
+            pulumi.set(__self__, "group_file_uri", group_file_uri)
+        if ldap_base_dn is not None:
+            pulumi.set(__self__, "ldap_base_dn", ldap_base_dn)
+        if ldap_server is not None:
+            pulumi.set(__self__, "ldap_server", ldap_server)
+        if require_valid_certificate is None:
+            require_valid_certificate = False
+        if require_valid_certificate is not None:
+            pulumi.set(__self__, "require_valid_certificate", require_valid_certificate)
+        if user_file_uri is not None:
+            pulumi.set(__self__, "user_file_uri", user_file_uri)
+        if username_source is None:
+            username_source = 'None'
+        if username_source is not None:
+            pulumi.set(__self__, "username_source", username_source)
+
+    @property
+    @pulumi.getter(name="usernameDownloaded")
+    def username_downloaded(self) -> str:
+        """
+        Indicates whether or not the HPC Cache has performed the username download successfully.
+        """
+        return pulumi.get(self, "username_downloaded")
+
+    @property
+    @pulumi.getter(name="autoDownloadCertificate")
+    def auto_download_certificate(self) -> Optional[bool]:
+        """
+        Determines if the certificate should be automatically downloaded. This applies to 'caCertificateURI' only if 'requireValidCertificate' is true.
+        """
+        return pulumi.get(self, "auto_download_certificate")
+
+    @property
+    @pulumi.getter(name="caCertificateURI")
+    def ca_certificate_uri(self) -> Optional[str]:
+        """
+        The URI of the CA certificate to validate the LDAP secure connection. This field must be populated when 'requireValidCertificate' is set to true.
+        """
+        return pulumi.get(self, "ca_certificate_uri")
+
+    @property
+    @pulumi.getter
+    def credentials(self) -> Optional['outputs.CacheUsernameDownloadSettingsResponseCredentials']:
+        """
+        When present, these are the credentials for the secure LDAP connection.
+        """
+        return pulumi.get(self, "credentials")
+
+    @property
+    @pulumi.getter(name="encryptLdapConnection")
+    def encrypt_ldap_connection(self) -> Optional[bool]:
+        """
+        Whether or not the LDAP connection should be encrypted.
+        """
+        return pulumi.get(self, "encrypt_ldap_connection")
+
+    @property
+    @pulumi.getter(name="extendedGroups")
+    def extended_groups(self) -> Optional[bool]:
+        """
+        Whether or not Extended Groups is enabled.
+        """
+        return pulumi.get(self, "extended_groups")
+
+    @property
+    @pulumi.getter(name="groupFileURI")
+    def group_file_uri(self) -> Optional[str]:
+        """
+        The URI of the file containing group information (in /etc/group file format). This field must be populated when 'usernameSource' is set to 'File'.
+        """
+        return pulumi.get(self, "group_file_uri")
+
+    @property
+    @pulumi.getter(name="ldapBaseDN")
+    def ldap_base_dn(self) -> Optional[str]:
+        """
+        The base distinguished name for the LDAP domain.
+        """
+        return pulumi.get(self, "ldap_base_dn")
+
+    @property
+    @pulumi.getter(name="ldapServer")
+    def ldap_server(self) -> Optional[str]:
+        """
+        The fully qualified domain name or IP address of the LDAP server to use.
+        """
+        return pulumi.get(self, "ldap_server")
+
+    @property
+    @pulumi.getter(name="requireValidCertificate")
+    def require_valid_certificate(self) -> Optional[bool]:
+        """
+        Determines if the certificates must be validated by a certificate authority. When true, caCertificateURI must be provided.
+        """
+        return pulumi.get(self, "require_valid_certificate")
+
+    @property
+    @pulumi.getter(name="userFileURI")
+    def user_file_uri(self) -> Optional[str]:
+        """
+        The URI of the file containing user information (in /etc/passwd file format). This field must be populated when 'usernameSource' is set to 'File'.
+        """
+        return pulumi.get(self, "user_file_uri")
+
+    @property
+    @pulumi.getter(name="usernameSource")
+    def username_source(self) -> Optional[str]:
+        """
+        This setting determines how the cache gets username and group names for clients.
+        """
+        return pulumi.get(self, "username_source")
+
+
+@pulumi.output_type
+class CacheUsernameDownloadSettingsResponseCredentials(dict):
+    """
+    When present, these are the credentials for the secure LDAP connection.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bindDn":
+            suggest = "bind_dn"
+        elif key == "bindPassword":
+            suggest = "bind_password"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheUsernameDownloadSettingsResponseCredentials. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheUsernameDownloadSettingsResponseCredentials.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheUsernameDownloadSettingsResponseCredentials.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bind_dn: Optional[str] = None,
+                 bind_password: Optional[str] = None):
+        """
+        When present, these are the credentials for the secure LDAP connection.
+        :param str bind_dn: The Bind Distinguished Name identity to be used in the secure LDAP connection. This value is stored encrypted and not returned on response.
+        :param str bind_password: The Bind password to be used in the secure LDAP connection. This value is stored encrypted and not returned on response.
+        """
+        if bind_dn is not None:
+            pulumi.set(__self__, "bind_dn", bind_dn)
+        if bind_password is not None:
+            pulumi.set(__self__, "bind_password", bind_password)
+
+    @property
+    @pulumi.getter(name="bindDn")
+    def bind_dn(self) -> Optional[str]:
+        """
+        The Bind Distinguished Name identity to be used in the secure LDAP connection. This value is stored encrypted and not returned on response.
+        """
+        return pulumi.get(self, "bind_dn")
+
+    @property
+    @pulumi.getter(name="bindPassword")
+    def bind_password(self) -> Optional[str]:
+        """
+        The Bind password to be used in the secure LDAP connection. This value is stored encrypted and not returned on response.
+        """
+        return pulumi.get(self, "bind_password")
+
+
+@pulumi.output_type
+class ClfsTargetResponse(dict):
+    """
+    Properties pertaining to the ClfsTarget
+    """
+    def __init__(__self__, *,
+                 target: Optional[str] = None):
+        """
+        Properties pertaining to the ClfsTarget
+        :param str target: Resource ID of storage container.
+        """
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional[str]:
+        """
+        Resource ID of storage container.
+        """
+        return pulumi.get(self, "target")
+
+
+@pulumi.output_type
+class ConditionResponse(dict):
+    """
+    Outstanding conditions that will need to be resolved.
+    """
+    def __init__(__self__, *,
+                 message: str,
+                 timestamp: str):
+        """
+        Outstanding conditions that will need to be resolved.
+        :param str message: The issue requiring attention.
+        :param str timestamp: The time when the condition was raised.
+        """
+        pulumi.set(__self__, "message", message)
+        pulumi.set(__self__, "timestamp", timestamp)
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        The issue requiring attention.
+        """
+        return pulumi.get(self, "message")
+
+    @property
+    @pulumi.getter
+    def timestamp(self) -> str:
+        """
+        The time when the condition was raised.
+        """
+        return pulumi.get(self, "timestamp")
+
+
+@pulumi.output_type
+class KeyVaultKeyReferenceResponse(dict):
+    """
+    Describes a reference to key vault key.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyUrl":
+            suggest = "key_url"
+        elif key == "sourceVault":
+            suggest = "source_vault"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KeyVaultKeyReferenceResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KeyVaultKeyReferenceResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KeyVaultKeyReferenceResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_url: str,
+                 source_vault: 'outputs.KeyVaultKeyReferenceResponseSourceVault'):
+        """
+        Describes a reference to key vault key.
+        :param str key_url: The URL referencing a key encryption key in key vault.
+        :param 'KeyVaultKeyReferenceResponseSourceVault' source_vault: Describes a resource Id to source key vault.
+        """
+        pulumi.set(__self__, "key_url", key_url)
+        pulumi.set(__self__, "source_vault", source_vault)
+
+    @property
+    @pulumi.getter(name="keyUrl")
+    def key_url(self) -> str:
+        """
+        The URL referencing a key encryption key in key vault.
+        """
+        return pulumi.get(self, "key_url")
+
+    @property
+    @pulumi.getter(name="sourceVault")
+    def source_vault(self) -> 'outputs.KeyVaultKeyReferenceResponseSourceVault':
+        """
+        Describes a resource Id to source key vault.
+        """
+        return pulumi.get(self, "source_vault")
+
+
+@pulumi.output_type
+class KeyVaultKeyReferenceResponseSourceVault(dict):
+    """
+    Describes a resource Id to source key vault.
+    """
+    def __init__(__self__, *,
+                 id: Optional[str] = None):
+        """
+        Describes a resource Id to source key vault.
+        :param str id: Resource Id.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource Id.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class NamespaceJunctionResponse(dict):
+    """
+    A namespace junction.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "namespacePath":
+            suggest = "namespace_path"
+        elif key == "nfsAccessPolicy":
+            suggest = "nfs_access_policy"
+        elif key == "nfsExport":
+            suggest = "nfs_export"
+        elif key == "targetPath":
+            suggest = "target_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NamespaceJunctionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NamespaceJunctionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NamespaceJunctionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 namespace_path: Optional[str] = None,
+                 nfs_access_policy: Optional[str] = None,
+                 nfs_export: Optional[str] = None,
+                 target_path: Optional[str] = None):
+        """
+        A namespace junction.
+        :param str namespace_path: Namespace path on a cache for a Storage Target.
+        :param str nfs_access_policy: Name of the access policy applied to this junction.
+        :param str nfs_export: NFS export where targetPath exists.
+        :param str target_path: Path in Storage Target to which namespacePath points.
+        """
+        if namespace_path is not None:
+            pulumi.set(__self__, "namespace_path", namespace_path)
+        if nfs_access_policy is None:
+            nfs_access_policy = 'default'
+        if nfs_access_policy is not None:
+            pulumi.set(__self__, "nfs_access_policy", nfs_access_policy)
+        if nfs_export is not None:
+            pulumi.set(__self__, "nfs_export", nfs_export)
+        if target_path is not None:
+            pulumi.set(__self__, "target_path", target_path)
+
+    @property
+    @pulumi.getter(name="namespacePath")
+    def namespace_path(self) -> Optional[str]:
+        """
+        Namespace path on a cache for a Storage Target.
+        """
+        return pulumi.get(self, "namespace_path")
+
+    @property
+    @pulumi.getter(name="nfsAccessPolicy")
+    def nfs_access_policy(self) -> Optional[str]:
+        """
+        Name of the access policy applied to this junction.
+        """
+        return pulumi.get(self, "nfs_access_policy")
+
+    @property
+    @pulumi.getter(name="nfsExport")
+    def nfs_export(self) -> Optional[str]:
+        """
+        NFS export where targetPath exists.
+        """
+        return pulumi.get(self, "nfs_export")
+
+    @property
+    @pulumi.getter(name="targetPath")
+    def target_path(self) -> Optional[str]:
+        """
+        Path in Storage Target to which namespacePath points.
+        """
+        return pulumi.get(self, "target_path")
+
+
+@pulumi.output_type
+class Nfs3TargetResponse(dict):
+    """
+    Properties pertaining to the Nfs3Target
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "usageModel":
+            suggest = "usage_model"
+        elif key == "verificationTimer":
+            suggest = "verification_timer"
+        elif key == "writeBackTimer":
+            suggest = "write_back_timer"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in Nfs3TargetResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        Nfs3TargetResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        Nfs3TargetResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 target: Optional[str] = None,
+                 usage_model: Optional[str] = None,
+                 verification_timer: Optional[int] = None,
+                 write_back_timer: Optional[int] = None):
+        """
+        Properties pertaining to the Nfs3Target
+        :param str target: IP address or host name of an NFSv3 host (e.g., 10.0.44.44).
+        :param str usage_model: Identifies the StorageCache usage model to be used for this storage target.
+        :param int verification_timer: Amount of time (in seconds) the cache waits before it checks the back-end storage for file updates.
+        :param int write_back_timer: Amount of time (in seconds) the cache waits after the last file change before it copies the changed file to back-end storage.
+        """
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+        if usage_model is not None:
+            pulumi.set(__self__, "usage_model", usage_model)
+        if verification_timer is not None:
+            pulumi.set(__self__, "verification_timer", verification_timer)
+        if write_back_timer is not None:
+            pulumi.set(__self__, "write_back_timer", write_back_timer)
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional[str]:
+        """
+        IP address or host name of an NFSv3 host (e.g., 10.0.44.44).
+        """
+        return pulumi.get(self, "target")
+
+    @property
+    @pulumi.getter(name="usageModel")
+    def usage_model(self) -> Optional[str]:
+        """
+        Identifies the StorageCache usage model to be used for this storage target.
+        """
+        return pulumi.get(self, "usage_model")
+
+    @property
+    @pulumi.getter(name="verificationTimer")
+    def verification_timer(self) -> Optional[int]:
+        """
+        Amount of time (in seconds) the cache waits before it checks the back-end storage for file updates.
+        """
+        return pulumi.get(self, "verification_timer")
+
+    @property
+    @pulumi.getter(name="writeBackTimer")
+    def write_back_timer(self) -> Optional[int]:
+        """
+        Amount of time (in seconds) the cache waits after the last file change before it copies the changed file to back-end storage.
+        """
+        return pulumi.get(self, "write_back_timer")
+
+
+@pulumi.output_type
+class NfsAccessPolicyResponse(dict):
+    """
+    A set of rules describing access policies applied to NFSv3 clients of the cache.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessRules":
+            suggest = "access_rules"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NfsAccessPolicyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NfsAccessPolicyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NfsAccessPolicyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_rules: Sequence['outputs.NfsAccessRuleResponse'],
+                 name: str):
+        """
+        A set of rules describing access policies applied to NFSv3 clients of the cache.
+        :param Sequence['NfsAccessRuleResponse'] access_rules: The set of rules describing client accesses allowed under this policy.
+        :param str name: Name identifying this policy. Access Policy names are not case sensitive.
+        """
+        pulumi.set(__self__, "access_rules", access_rules)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="accessRules")
+    def access_rules(self) -> Sequence['outputs.NfsAccessRuleResponse']:
+        """
+        The set of rules describing client accesses allowed under this policy.
+        """
+        return pulumi.get(self, "access_rules")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name identifying this policy. Access Policy names are not case sensitive.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class NfsAccessRuleResponse(dict):
+    """
+    Rule to place restrictions on portions of the cache namespace being presented to clients.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "anonymousGID":
+            suggest = "anonymous_gid"
+        elif key == "anonymousUID":
+            suggest = "anonymous_uid"
+        elif key == "rootSquash":
+            suggest = "root_squash"
+        elif key == "submountAccess":
+            suggest = "submount_access"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NfsAccessRuleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NfsAccessRuleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NfsAccessRuleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access: str,
+                 scope: str,
+                 anonymous_gid: Optional[str] = None,
+                 anonymous_uid: Optional[str] = None,
+                 filter: Optional[str] = None,
+                 root_squash: Optional[bool] = None,
+                 submount_access: Optional[bool] = None,
+                 suid: Optional[bool] = None):
+        """
+        Rule to place restrictions on portions of the cache namespace being presented to clients.
+        :param str access: Access allowed by this rule.
+        :param str scope: Scope for this rule. The scope and filter determine which clients match the rule.
+        :param str anonymous_gid: GID value that replaces 0 when rootSquash is true. This will use the value of anonymousUID if not provided.
+        :param str anonymous_uid: UID value that replaces 0 when rootSquash is true. 65534 will be used if not provided.
+        :param str filter: Filter applied to the scope for this rule. The filter's format depends on its scope. 'default' scope matches all clients and has no filter value. 'network' scope takes a filter in CIDR format (for example, 10.99.1.0/24). 'host' takes an IP address or fully qualified domain name as filter. If a client does not match any filter rule and there is no default rule, access is denied.
+        :param bool root_squash: Map root accesses to anonymousUID and anonymousGID.
+        :param bool submount_access: For the default policy, allow access to subdirectories under the root export. If this is set to no, clients can only mount the path '/'. If set to yes, clients can mount a deeper path, like '/a/b'.
+        :param bool suid: Allow SUID semantics.
+        """
+        pulumi.set(__self__, "access", access)
+        pulumi.set(__self__, "scope", scope)
+        if anonymous_gid is not None:
+            pulumi.set(__self__, "anonymous_gid", anonymous_gid)
+        if anonymous_uid is not None:
+            pulumi.set(__self__, "anonymous_uid", anonymous_uid)
+        if filter is not None:
+            pulumi.set(__self__, "filter", filter)
+        if root_squash is not None:
+            pulumi.set(__self__, "root_squash", root_squash)
+        if submount_access is not None:
+            pulumi.set(__self__, "submount_access", submount_access)
+        if suid is not None:
+            pulumi.set(__self__, "suid", suid)
+
+    @property
+    @pulumi.getter
+    def access(self) -> str:
+        """
+        Access allowed by this rule.
+        """
+        return pulumi.get(self, "access")
+
+    @property
+    @pulumi.getter
+    def scope(self) -> str:
+        """
+        Scope for this rule. The scope and filter determine which clients match the rule.
+        """
+        return pulumi.get(self, "scope")
+
+    @property
+    @pulumi.getter(name="anonymousGID")
+    def anonymous_gid(self) -> Optional[str]:
+        """
+        GID value that replaces 0 when rootSquash is true. This will use the value of anonymousUID if not provided.
+        """
+        return pulumi.get(self, "anonymous_gid")
+
+    @property
+    @pulumi.getter(name="anonymousUID")
+    def anonymous_uid(self) -> Optional[str]:
+        """
+        UID value that replaces 0 when rootSquash is true. 65534 will be used if not provided.
+        """
+        return pulumi.get(self, "anonymous_uid")
+
+    @property
+    @pulumi.getter
+    def filter(self) -> Optional[str]:
+        """
+        Filter applied to the scope for this rule. The filter's format depends on its scope. 'default' scope matches all clients and has no filter value. 'network' scope takes a filter in CIDR format (for example, 10.99.1.0/24). 'host' takes an IP address or fully qualified domain name as filter. If a client does not match any filter rule and there is no default rule, access is denied.
+        """
+        return pulumi.get(self, "filter")
+
+    @property
+    @pulumi.getter(name="rootSquash")
+    def root_squash(self) -> Optional[bool]:
+        """
+        Map root accesses to anonymousUID and anonymousGID.
+        """
+        return pulumi.get(self, "root_squash")
+
+    @property
+    @pulumi.getter(name="submountAccess")
+    def submount_access(self) -> Optional[bool]:
+        """
+        For the default policy, allow access to subdirectories under the root export. If this is set to no, clients can only mount the path '/'. If set to yes, clients can mount a deeper path, like '/a/b'.
+        """
+        return pulumi.get(self, "submount_access")
+
+    @property
+    @pulumi.getter
+    def suid(self) -> Optional[bool]:
+        """
+        Allow SUID semantics.
+        """
+        return pulumi.get(self, "suid")
+
+
+@pulumi.output_type
+class PrimingJobResponse(dict):
+    """
+    A priming job instance.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "primingJobDetails":
+            suggest = "priming_job_details"
+        elif key == "primingJobId":
+            suggest = "priming_job_id"
+        elif key == "primingJobName":
+            suggest = "priming_job_name"
+        elif key == "primingJobPercentComplete":
+            suggest = "priming_job_percent_complete"
+        elif key == "primingJobState":
+            suggest = "priming_job_state"
+        elif key == "primingJobStatus":
+            suggest = "priming_job_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrimingJobResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrimingJobResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrimingJobResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 priming_job_details: str,
+                 priming_job_id: str,
+                 priming_job_name: str,
+                 priming_job_percent_complete: float,
+                 priming_job_state: str,
+                 priming_job_status: str):
+        """
+        A priming job instance.
+        :param str priming_job_details: The job details or error information if any.
+        :param str priming_job_id: The unique identifier of the priming job.
+        :param str priming_job_name: The priming job name.
+        :param float priming_job_percent_complete: The current progress of the priming job, as a percentage.
+        :param str priming_job_state: The state of the priming operation.
+        :param str priming_job_status: The status code of the priming job.
+        """
+        pulumi.set(__self__, "priming_job_details", priming_job_details)
+        pulumi.set(__self__, "priming_job_id", priming_job_id)
+        pulumi.set(__self__, "priming_job_name", priming_job_name)
+        pulumi.set(__self__, "priming_job_percent_complete", priming_job_percent_complete)
+        pulumi.set(__self__, "priming_job_state", priming_job_state)
+        pulumi.set(__self__, "priming_job_status", priming_job_status)
+
+    @property
+    @pulumi.getter(name="primingJobDetails")
+    def priming_job_details(self) -> str:
+        """
+        The job details or error information if any.
+        """
+        return pulumi.get(self, "priming_job_details")
+
+    @property
+    @pulumi.getter(name="primingJobId")
+    def priming_job_id(self) -> str:
+        """
+        The unique identifier of the priming job.
+        """
+        return pulumi.get(self, "priming_job_id")
+
+    @property
+    @pulumi.getter(name="primingJobName")
+    def priming_job_name(self) -> str:
+        """
+        The priming job name.
+        """
+        return pulumi.get(self, "priming_job_name")
+
+    @property
+    @pulumi.getter(name="primingJobPercentComplete")
+    def priming_job_percent_complete(self) -> float:
+        """
+        The current progress of the priming job, as a percentage.
+        """
+        return pulumi.get(self, "priming_job_percent_complete")
+
+    @property
+    @pulumi.getter(name="primingJobState")
+    def priming_job_state(self) -> str:
+        """
+        The state of the priming operation.
+        """
+        return pulumi.get(self, "priming_job_state")
+
+    @property
+    @pulumi.getter(name="primingJobStatus")
+    def priming_job_status(self) -> str:
+        """
+        The status code of the priming job.
+        """
+        return pulumi.get(self, "priming_job_status")
+
+
+@pulumi.output_type
+class SkuNameResponse(dict):
+    """
+    SKU for the resource.
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None):
+        """
+        SKU for the resource.
+        :param str name: SKU name for this resource.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        SKU name for this resource.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class StorageTargetSpaceAllocationResponse(dict):
+    """
+    Storage Target space allocation properties.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allocationPercentage":
+            suggest = "allocation_percentage"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StorageTargetSpaceAllocationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StorageTargetSpaceAllocationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StorageTargetSpaceAllocationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allocation_percentage: Optional[int] = None,
+                 name: Optional[str] = None):
+        """
+        Storage Target space allocation properties.
+        :param int allocation_percentage: The percentage of cache space allocated for this storage target
+        :param str name: Name of the storage target.
+        """
+        if allocation_percentage is not None:
+            pulumi.set(__self__, "allocation_percentage", allocation_percentage)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="allocationPercentage")
+    def allocation_percentage(self) -> Optional[int]:
+        """
+        The percentage of cache space allocated for this storage target
+        """
+        return pulumi.get(self, "allocation_percentage")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Name of the storage target.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class SystemDataResponse(dict):
+    """
+    Metadata pertaining to creation and last modification of the resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "createdBy":
+            suggest = "created_by"
+        elif key == "createdByType":
+            suggest = "created_by_type"
+        elif key == "lastModifiedAt":
+            suggest = "last_modified_at"
+        elif key == "lastModifiedBy":
+            suggest = "last_modified_by"
+        elif key == "lastModifiedByType":
+            suggest = "last_modified_by_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SystemDataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: Optional[str] = None,
+                 created_by: Optional[str] = None,
+                 created_by_type: Optional[str] = None,
+                 last_modified_at: Optional[str] = None,
+                 last_modified_by: Optional[str] = None,
+                 last_modified_by_type: Optional[str] = None):
+        """
+        Metadata pertaining to creation and last modification of the resource.
+        :param str created_at: The timestamp of resource creation (UTC).
+        :param str created_by: The identity that created the resource.
+        :param str created_by_type: The type of identity that created the resource.
+        :param str last_modified_at: The timestamp of resource last modification (UTC)
+        :param str last_modified_by: The identity that last modified the resource.
+        :param str last_modified_by_type: The type of identity that last modified the resource.
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_by_type is not None:
+            pulumi.set(__self__, "created_by_type", created_by_type)
+        if last_modified_at is not None:
+            pulumi.set(__self__, "last_modified_at", last_modified_at)
+        if last_modified_by is not None:
+            pulumi.set(__self__, "last_modified_by", last_modified_by)
+        if last_modified_by_type is not None:
+            pulumi.set(__self__, "last_modified_by_type", last_modified_by_type)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[str]:
+        """
+        The timestamp of resource creation (UTC).
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[str]:
+        """
+        The identity that created the resource.
+        """
+        return pulumi.get(self, "created_by")
+
+    @property
+    @pulumi.getter(name="createdByType")
+    def created_by_type(self) -> Optional[str]:
+        """
+        The type of identity that created the resource.
+        """
+        return pulumi.get(self, "created_by_type")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> Optional[str]:
+        """
+        The timestamp of resource last modification (UTC)
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter(name="lastModifiedBy")
+    def last_modified_by(self) -> Optional[str]:
+        """
+        The identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by")
+
+    @property
+    @pulumi.getter(name="lastModifiedByType")
+    def last_modified_by_type(self) -> Optional[str]:
+        """
+        The type of identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by_type")
+
+
+@pulumi.output_type
+class UnknownTargetResponse(dict):
+    """
+    Properties pertaining to the UnknownTarget
+    """
+    def __init__(__self__, *,
+                 attributes: Optional[Mapping[str, str]] = None):
+        """
+        Properties pertaining to the UnknownTarget
+        :param Mapping[str, str] attributes: Dictionary of string->string pairs containing information about the Storage Target.
+        """
+        if attributes is not None:
+            pulumi.set(__self__, "attributes", attributes)
+
+    @property
+    @pulumi.getter
+    def attributes(self) -> Optional[Mapping[str, str]]:
+        """
+        Dictionary of string->string pairs containing information about the Storage Target.
+        """
+        return pulumi.get(self, "attributes")
+
+
+@pulumi.output_type
+class UserAssignedIdentitiesResponseUserAssignedIdentities(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "principalId":
+            suggest = "principal_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UserAssignedIdentitiesResponseUserAssignedIdentities. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UserAssignedIdentitiesResponseUserAssignedIdentities.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UserAssignedIdentitiesResponseUserAssignedIdentities.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: str,
+                 principal_id: str):
+        """
+        :param str client_id: The client ID of the user-assigned identity.
+        :param str principal_id: The principal ID of the user-assigned identity.
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "principal_id", principal_id)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> str:
+        """
+        The client ID of the user-assigned identity.
+        """
+        return pulumi.get(self, "client_id")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID of the user-assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+