pulumi-azure-native 2.22.2a1703025967__py3-none-any.whl → 2.22.2a1703061934__py3-none-any.whl

pulumi_azure_native/hybridcontainerservice/v20240101/outputs.py

@@ -0,0 +1,2647 @@
+# 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 pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from ... import _utilities
+from . import outputs
+from ._enums import *
+
+__all__ = [
+    'AddonStatusProfileResponse',
+    'AgentPoolProvisioningStatusResponseStatus',
+    'AgentPoolUpdateProfileResponse',
+    'CloudProviderProfileResponse',
+    'CloudProviderProfileResponseInfraNetworkProfile',
+    'ClusterVMAccessProfileResponse',
+    'ControlPlaneProfileResponse',
+    'ControlPlaneProfileResponseControlPlaneEndpoint',
+    'CredentialResultResponse',
+    'ExtendedLocationResponse',
+    'KubernetesPatchVersionsResponse',
+    'KubernetesVersionProfileResponseProperties',
+    'KubernetesVersionPropertiesResponse',
+    'KubernetesVersionReadinessResponse',
+    'LinuxProfilePropertiesResponse',
+    'LinuxProfilePropertiesResponsePublicKeys',
+    'LinuxProfilePropertiesResponseSsh',
+    'ListCredentialResponseResponseError',
+    'ListCredentialResponseResponseProperties',
+    'NamedAgentPoolProfileResponse',
+    'NetworkProfileResponse',
+    'NetworkProfileResponseLoadBalancerProfile',
+    'ProvisionedClusterLicenseProfileResponse',
+    'ProvisionedClusterPropertiesResponse',
+    'ProvisionedClusterPropertiesResponseAutoScalerProfile',
+    'ProvisionedClusterPropertiesResponseStatus',
+    'StorageProfileNfsCSIDriverResponse',
+    'StorageProfileResponse',
+    'StorageProfileSmbCSIDriverResponse',
+    'SystemDataResponse',
+    'VirtualNetworkPropertiesResponse',
+    'VirtualNetworkPropertiesResponseError',
+    'VirtualNetworkPropertiesResponseHci',
+    'VirtualNetworkPropertiesResponseInfraVnetProfile',
+    'VirtualNetworkPropertiesResponseOperationStatus',
+    'VirtualNetworkPropertiesResponseStatus',
+    'VirtualNetworkPropertiesResponseVipPool',
+    'VirtualNetworkPropertiesResponseVmipPool',
+    'VirtualNetworkResponseExtendedLocation',
+    'VmSkuCapabilitiesResponse',
+    'VmSkuProfileResponseProperties',
+    'VmSkuPropertiesResponse',
+]
+
+@pulumi.output_type
+class AddonStatusProfileResponse(dict):
+    """
+    The status profile of the addons and other kubernetes components
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorMessage":
+            suggest = "error_message"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AddonStatusProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AddonStatusProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AddonStatusProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error_message: Optional[str] = None,
+                 name: Optional[str] = None,
+                 phase: Optional[str] = None,
+                 ready: Optional[bool] = None):
+        """
+        The status profile of the addons and other kubernetes components
+        :param str error_message: Observed error message from the addon or component
+        :param str name: Name of the addon or component
+        :param str phase: Observed phase of the addon or component on the provisioned cluster. Possible values include: 'pending', 'provisioning', 'provisioning {HelmChartInstalled}', 'provisioning {MSICertificateDownloaded}', 'provisioned', 'deleting', 'failed', 'upgrading'
+        :param bool ready: Indicates whether the addon or component is ready
+        """
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if phase is not None:
+            pulumi.set(__self__, "phase", phase)
+        if ready is not None:
+            pulumi.set(__self__, "ready", ready)
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[str]:
+        """
+        Observed error message from the addon or component
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Name of the addon or component
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def phase(self) -> Optional[str]:
+        """
+        Observed phase of the addon or component on the provisioned cluster. Possible values include: 'pending', 'provisioning', 'provisioning {HelmChartInstalled}', 'provisioning {MSICertificateDownloaded}', 'provisioned', 'deleting', 'failed', 'upgrading'
+        """
+        return pulumi.get(self, "phase")
+
+    @property
+    @pulumi.getter
+    def ready(self) -> Optional[bool]:
+        """
+        Indicates whether the addon or component is ready
+        """
+        return pulumi.get(self, "ready")
+
+
+@pulumi.output_type
+class AgentPoolProvisioningStatusResponseStatus(dict):
+    """
+    The observed status of the agent pool.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "currentState":
+            suggest = "current_state"
+        elif key == "errorMessage":
+            suggest = "error_message"
+        elif key == "readyReplicas":
+            suggest = "ready_replicas"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AgentPoolProvisioningStatusResponseStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AgentPoolProvisioningStatusResponseStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AgentPoolProvisioningStatusResponseStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 current_state: str,
+                 error_message: Optional[str] = None,
+                 ready_replicas: Optional[Sequence['outputs.AgentPoolUpdateProfileResponse']] = None):
+        """
+        The observed status of the agent pool.
+        :param str current_state: The current state of the agent pool.
+        :param str error_message: Error messages during an agent pool operation or steady state.
+        """
+        pulumi.set(__self__, "current_state", current_state)
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if ready_replicas is not None:
+            pulumi.set(__self__, "ready_replicas", ready_replicas)
+
+    @property
+    @pulumi.getter(name="currentState")
+    def current_state(self) -> str:
+        """
+        The current state of the agent pool.
+        """
+        return pulumi.get(self, "current_state")
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[str]:
+        """
+        Error messages during an agent pool operation or steady state.
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter(name="readyReplicas")
+    def ready_replicas(self) -> Optional[Sequence['outputs.AgentPoolUpdateProfileResponse']]:
+        return pulumi.get(self, "ready_replicas")
+
+
+@pulumi.output_type
+class AgentPoolUpdateProfileResponse(dict):
+    """
+    Profile for agent pool properties that can be updated
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kubernetesVersion":
+            suggest = "kubernetes_version"
+        elif key == "vmSize":
+            suggest = "vm_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AgentPoolUpdateProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AgentPoolUpdateProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AgentPoolUpdateProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 kubernetes_version: str,
+                 count: Optional[int] = None,
+                 vm_size: Optional[str] = None):
+        """
+        Profile for agent pool properties that can be updated
+        :param str kubernetes_version: Version of Kubernetes in use by the agent pool. This is inherited from the kubernetesVersion of the provisioned cluster.
+        :param int count: Number of nodes in the agent pool. The default value is 1.
+        :param str vm_size: The VM sku size of the agent pool node VMs.
+        """
+        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
+        if count is None:
+            count = 1
+        if count is not None:
+            pulumi.set(__self__, "count", count)
+        if vm_size is not None:
+            pulumi.set(__self__, "vm_size", vm_size)
+
+    @property
+    @pulumi.getter(name="kubernetesVersion")
+    def kubernetes_version(self) -> str:
+        """
+        Version of Kubernetes in use by the agent pool. This is inherited from the kubernetesVersion of the provisioned cluster.
+        """
+        return pulumi.get(self, "kubernetes_version")
+
+    @property
+    @pulumi.getter
+    def count(self) -> Optional[int]:
+        """
+        Number of nodes in the agent pool. The default value is 1.
+        """
+        return pulumi.get(self, "count")
+
+    @property
+    @pulumi.getter(name="vmSize")
+    def vm_size(self) -> Optional[str]:
+        """
+        The VM sku size of the agent pool node VMs.
+        """
+        return pulumi.get(self, "vm_size")
+
+
+@pulumi.output_type
+class CloudProviderProfileResponse(dict):
+    """
+    The profile for the underlying cloud infrastructure provider for the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "infraNetworkProfile":
+            suggest = "infra_network_profile"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CloudProviderProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CloudProviderProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CloudProviderProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 infra_network_profile: Optional['outputs.CloudProviderProfileResponseInfraNetworkProfile'] = None):
+        """
+        The profile for the underlying cloud infrastructure provider for the provisioned cluster.
+        :param 'CloudProviderProfileResponseInfraNetworkProfile' infra_network_profile: The profile for the infrastructure networks used by the provisioned cluster
+        """
+        if infra_network_profile is not None:
+            pulumi.set(__self__, "infra_network_profile", infra_network_profile)
+
+    @property
+    @pulumi.getter(name="infraNetworkProfile")
+    def infra_network_profile(self) -> Optional['outputs.CloudProviderProfileResponseInfraNetworkProfile']:
+        """
+        The profile for the infrastructure networks used by the provisioned cluster
+        """
+        return pulumi.get(self, "infra_network_profile")
+
+
+@pulumi.output_type
+class CloudProviderProfileResponseInfraNetworkProfile(dict):
+    """
+    The profile for the infrastructure networks used by the provisioned cluster
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "vnetSubnetIds":
+            suggest = "vnet_subnet_ids"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CloudProviderProfileResponseInfraNetworkProfile. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CloudProviderProfileResponseInfraNetworkProfile.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CloudProviderProfileResponseInfraNetworkProfile.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 vnet_subnet_ids: Optional[Sequence[str]] = None):
+        """
+        The profile for the infrastructure networks used by the provisioned cluster
+        :param Sequence[str] vnet_subnet_ids: List of ARM resource Ids (maximum 1) for the infrastructure network object e.g. /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/logicalNetworks/{logicalNetworkName}
+        """
+        if vnet_subnet_ids is not None:
+            pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
+
+    @property
+    @pulumi.getter(name="vnetSubnetIds")
+    def vnet_subnet_ids(self) -> Optional[Sequence[str]]:
+        """
+        List of ARM resource Ids (maximum 1) for the infrastructure network object e.g. /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/logicalNetworks/{logicalNetworkName}
+        """
+        return pulumi.get(self, "vnet_subnet_ids")
+
+
+@pulumi.output_type
+class ClusterVMAccessProfileResponse(dict):
+    """
+    The SSH restricted access profile for the VMs in the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authorizedIPRanges":
+            suggest = "authorized_ip_ranges"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterVMAccessProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterVMAccessProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterVMAccessProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authorized_ip_ranges: Optional[str] = None):
+        """
+        The SSH restricted access profile for the VMs in the provisioned cluster.
+        :param str authorized_ip_ranges: IP Address or CIDR for SSH access to VMs in the provisioned cluster
+        """
+        if authorized_ip_ranges is not None:
+            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
+
+    @property
+    @pulumi.getter(name="authorizedIPRanges")
+    def authorized_ip_ranges(self) -> Optional[str]:
+        """
+        IP Address or CIDR for SSH access to VMs in the provisioned cluster
+        """
+        return pulumi.get(self, "authorized_ip_ranges")
+
+
+@pulumi.output_type
+class ControlPlaneProfileResponse(dict):
+    """
+    The properties of the control plane nodes of the provisioned cluster
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "controlPlaneEndpoint":
+            suggest = "control_plane_endpoint"
+        elif key == "vmSize":
+            suggest = "vm_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ControlPlaneProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ControlPlaneProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ControlPlaneProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 control_plane_endpoint: Optional['outputs.ControlPlaneProfileResponseControlPlaneEndpoint'] = None,
+                 count: Optional[int] = None,
+                 vm_size: Optional[str] = None):
+        """
+        The properties of the control plane nodes of the provisioned cluster
+        :param 'ControlPlaneProfileResponseControlPlaneEndpoint' control_plane_endpoint: IP Address of the Kubernetes API server
+        :param int count: Number of control plane nodes. The default value is 1, and the count should be an odd number
+        :param str vm_size: VM sku size of the control plane nodes
+        """
+        if control_plane_endpoint is not None:
+            pulumi.set(__self__, "control_plane_endpoint", control_plane_endpoint)
+        if count is None:
+            count = 1
+        if count is not None:
+            pulumi.set(__self__, "count", count)
+        if vm_size is not None:
+            pulumi.set(__self__, "vm_size", vm_size)
+
+    @property
+    @pulumi.getter(name="controlPlaneEndpoint")
+    def control_plane_endpoint(self) -> Optional['outputs.ControlPlaneProfileResponseControlPlaneEndpoint']:
+        """
+        IP Address of the Kubernetes API server
+        """
+        return pulumi.get(self, "control_plane_endpoint")
+
+    @property
+    @pulumi.getter
+    def count(self) -> Optional[int]:
+        """
+        Number of control plane nodes. The default value is 1, and the count should be an odd number
+        """
+        return pulumi.get(self, "count")
+
+    @property
+    @pulumi.getter(name="vmSize")
+    def vm_size(self) -> Optional[str]:
+        """
+        VM sku size of the control plane nodes
+        """
+        return pulumi.get(self, "vm_size")
+
+
+@pulumi.output_type
+class ControlPlaneProfileResponseControlPlaneEndpoint(dict):
+    """
+    IP Address of the Kubernetes API server
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "hostIP":
+            suggest = "host_ip"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ControlPlaneProfileResponseControlPlaneEndpoint. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ControlPlaneProfileResponseControlPlaneEndpoint.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ControlPlaneProfileResponseControlPlaneEndpoint.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host_ip: Optional[str] = None):
+        """
+        IP Address of the Kubernetes API server
+        :param str host_ip: IP address of the Kubernetes API server
+        """
+        if host_ip is not None:
+            pulumi.set(__self__, "host_ip", host_ip)
+
+    @property
+    @pulumi.getter(name="hostIP")
+    def host_ip(self) -> Optional[str]:
+        """
+        IP address of the Kubernetes API server
+        """
+        return pulumi.get(self, "host_ip")
+
+
+@pulumi.output_type
+class CredentialResultResponse(dict):
+    """
+    The credential result response.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 value: str):
+        """
+        The credential result response.
+        :param str name: The name of the credential.
+        :param str value: Base64-encoded Kubernetes configuration file.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the credential.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        Base64-encoded Kubernetes configuration file.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ExtendedLocationResponse(dict):
+    """
+    Extended location pointing to the underlying infrastructure
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        Extended location pointing to the underlying infrastructure
+        :param str name: ARM Id of the extended location.
+        :param str type: The extended location type. Allowed value: 'CustomLocation'
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        ARM Id of the extended location.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The extended location type. Allowed value: 'CustomLocation'
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class KubernetesPatchVersionsResponse(dict):
+    """
+    Kubernetes Patch Version profile
+    """
+    def __init__(__self__, *,
+                 readiness: Optional[Sequence['outputs.KubernetesVersionReadinessResponse']] = None,
+                 upgrades: Optional[Sequence[str]] = None):
+        """
+        Kubernetes Patch Version profile
+        :param Sequence['KubernetesVersionReadinessResponse'] readiness: Indicates whether the kubernetes version image is ready or not
+        :param Sequence[str] upgrades: Possible upgrade paths for given patch version
+        """
+        if readiness is not None:
+            pulumi.set(__self__, "readiness", readiness)
+        if upgrades is not None:
+            pulumi.set(__self__, "upgrades", upgrades)
+
+    @property
+    @pulumi.getter
+    def readiness(self) -> Optional[Sequence['outputs.KubernetesVersionReadinessResponse']]:
+        """
+        Indicates whether the kubernetes version image is ready or not
+        """
+        return pulumi.get(self, "readiness")
+
+    @property
+    @pulumi.getter
+    def upgrades(self) -> Optional[Sequence[str]]:
+        """
+        Possible upgrade paths for given patch version
+        """
+        return pulumi.get(self, "upgrades")
+
+
+@pulumi.output_type
+class KubernetesVersionProfileResponseProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KubernetesVersionProfileResponseProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KubernetesVersionProfileResponseProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KubernetesVersionProfileResponseProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: str,
+                 values: Optional[Sequence['outputs.KubernetesVersionPropertiesResponse']] = None):
+        """
+        :param str provisioning_state: Provisioning state of the resource
+        :param Sequence['KubernetesVersionPropertiesResponse'] values: List of supported Kubernetes versions
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if values is not None:
+            pulumi.set(__self__, "values", values)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        Provisioning state of the resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def values(self) -> Optional[Sequence['outputs.KubernetesVersionPropertiesResponse']]:
+        """
+        List of supported Kubernetes versions
+        """
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class KubernetesVersionPropertiesResponse(dict):
+    """
+    Kubernetes version profile for given major.minor release
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "isPreview":
+            suggest = "is_preview"
+        elif key == "patchVersions":
+            suggest = "patch_versions"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KubernetesVersionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KubernetesVersionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KubernetesVersionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 is_preview: bool,
+                 patch_versions: Mapping[str, 'outputs.KubernetesPatchVersionsResponse'],
+                 version: str):
+        """
+        Kubernetes version profile for given major.minor release
+        :param bool is_preview: Whether this version is in preview mode.
+        :param Mapping[str, 'KubernetesPatchVersionsResponse'] patch_versions: Patch versions of a Kubernetes release
+        :param str version: major.minor version of Kubernetes release
+        """
+        pulumi.set(__self__, "is_preview", is_preview)
+        pulumi.set(__self__, "patch_versions", patch_versions)
+        pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter(name="isPreview")
+    def is_preview(self) -> bool:
+        """
+        Whether this version is in preview mode.
+        """
+        return pulumi.get(self, "is_preview")
+
+    @property
+    @pulumi.getter(name="patchVersions")
+    def patch_versions(self) -> Mapping[str, 'outputs.KubernetesPatchVersionsResponse']:
+        """
+        Patch versions of a Kubernetes release
+        """
+        return pulumi.get(self, "patch_versions")
+
+    @property
+    @pulumi.getter
+    def version(self) -> str:
+        """
+        major.minor version of Kubernetes release
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class KubernetesVersionReadinessResponse(dict):
+    """
+    Indicates whether the kubernetes version image is ready or not
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorMessage":
+            suggest = "error_message"
+        elif key == "osType":
+            suggest = "os_type"
+        elif key == "osSku":
+            suggest = "os_sku"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KubernetesVersionReadinessResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KubernetesVersionReadinessResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KubernetesVersionReadinessResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error_message: str,
+                 os_type: Optional[str] = None,
+                 ready: bool,
+                 os_sku: Optional[str] = None):
+        """
+        Indicates whether the kubernetes version image is ready or not
+        :param str error_message: The error message for version not being ready
+        :param str os_type: The particular KubernetesVersion Image OS Type (Linux, Windows)
+        :param bool ready: Whether the kubernetes version image is ready or not
+        :param str os_sku: Specifies the OS SKU used by the agent pool. The default is CBLMariner if OSType is Linux. The default is Windows2019 when OSType is Windows.
+        """
+        pulumi.set(__self__, "error_message", error_message)
+        if os_type is None:
+            os_type = 'Linux'
+        pulumi.set(__self__, "os_type", os_type)
+        pulumi.set(__self__, "ready", ready)
+        if os_sku is not None:
+            pulumi.set(__self__, "os_sku", os_sku)
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> str:
+        """
+        The error message for version not being ready
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter(name="osType")
+    def os_type(self) -> str:
+        """
+        The particular KubernetesVersion Image OS Type (Linux, Windows)
+        """
+        return pulumi.get(self, "os_type")
+
+    @property
+    @pulumi.getter
+    def ready(self) -> bool:
+        """
+        Whether the kubernetes version image is ready or not
+        """
+        return pulumi.get(self, "ready")
+
+    @property
+    @pulumi.getter(name="osSku")
+    def os_sku(self) -> Optional[str]:
+        """
+        Specifies the OS SKU used by the agent pool. The default is CBLMariner if OSType is Linux. The default is Windows2019 when OSType is Windows.
+        """
+        return pulumi.get(self, "os_sku")
+
+
+@pulumi.output_type
+class LinuxProfilePropertiesResponse(dict):
+    """
+    SSH profile for control plane and nodepool VMs of the provisioned cluster.
+    """
+    def __init__(__self__, *,
+                 ssh: Optional['outputs.LinuxProfilePropertiesResponseSsh'] = None):
+        """
+        SSH profile for control plane and nodepool VMs of the provisioned cluster.
+        :param 'LinuxProfilePropertiesResponseSsh' ssh: SSH configuration for VMs of the provisioned cluster.
+        """
+        if ssh is not None:
+            pulumi.set(__self__, "ssh", ssh)
+
+    @property
+    @pulumi.getter
+    def ssh(self) -> Optional['outputs.LinuxProfilePropertiesResponseSsh']:
+        """
+        SSH configuration for VMs of the provisioned cluster.
+        """
+        return pulumi.get(self, "ssh")
+
+
+@pulumi.output_type
+class LinuxProfilePropertiesResponsePublicKeys(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyData":
+            suggest = "key_data"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LinuxProfilePropertiesResponsePublicKeys. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LinuxProfilePropertiesResponsePublicKeys.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LinuxProfilePropertiesResponsePublicKeys.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_data: Optional[str] = None):
+        """
+        :param str key_data: Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
+        """
+        if key_data is not None:
+            pulumi.set(__self__, "key_data", key_data)
+
+    @property
+    @pulumi.getter(name="keyData")
+    def key_data(self) -> Optional[str]:
+        """
+        Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with or without headers.
+        """
+        return pulumi.get(self, "key_data")
+
+
+@pulumi.output_type
+class LinuxProfilePropertiesResponseSsh(dict):
+    """
+    SSH configuration for VMs of the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "publicKeys":
+            suggest = "public_keys"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LinuxProfilePropertiesResponseSsh. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LinuxProfilePropertiesResponseSsh.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LinuxProfilePropertiesResponseSsh.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 public_keys: Optional[Sequence['outputs.LinuxProfilePropertiesResponsePublicKeys']] = None):
+        """
+        SSH configuration for VMs of the provisioned cluster.
+        :param Sequence['LinuxProfilePropertiesResponsePublicKeys'] public_keys: The list of SSH public keys used to authenticate with VMs. A maximum of 1 key may be specified.
+        """
+        if public_keys is not None:
+            pulumi.set(__self__, "public_keys", public_keys)
+
+    @property
+    @pulumi.getter(name="publicKeys")
+    def public_keys(self) -> Optional[Sequence['outputs.LinuxProfilePropertiesResponsePublicKeys']]:
+        """
+        The list of SSH public keys used to authenticate with VMs. A maximum of 1 key may be specified.
+        """
+        return pulumi.get(self, "public_keys")
+
+
+@pulumi.output_type
+class ListCredentialResponseResponseError(dict):
+    def __init__(__self__, *,
+                 code: Optional[str] = None,
+                 message: Optional[str] = None):
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[str]:
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[str]:
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class ListCredentialResponseResponseProperties(dict):
+    def __init__(__self__, *,
+                 kubeconfigs: Sequence['outputs.CredentialResultResponse']):
+        """
+        :param Sequence['CredentialResultResponse'] kubeconfigs: Base64-encoded Kubernetes configuration file.
+        """
+        pulumi.set(__self__, "kubeconfigs", kubeconfigs)
+
+    @property
+    @pulumi.getter
+    def kubeconfigs(self) -> Sequence['outputs.CredentialResultResponse']:
+        """
+        Base64-encoded Kubernetes configuration file.
+        """
+        return pulumi.get(self, "kubeconfigs")
+
+
+@pulumi.output_type
+class NamedAgentPoolProfileResponse(dict):
+    """
+    Profile of the default agent pool along with a name parameter
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kubernetesVersion":
+            suggest = "kubernetes_version"
+        elif key == "enableAutoScaling":
+            suggest = "enable_auto_scaling"
+        elif key == "maxCount":
+            suggest = "max_count"
+        elif key == "maxPods":
+            suggest = "max_pods"
+        elif key == "minCount":
+            suggest = "min_count"
+        elif key == "nodeLabels":
+            suggest = "node_labels"
+        elif key == "nodeTaints":
+            suggest = "node_taints"
+        elif key == "osSKU":
+            suggest = "os_sku"
+        elif key == "osType":
+            suggest = "os_type"
+        elif key == "vmSize":
+            suggest = "vm_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NamedAgentPoolProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NamedAgentPoolProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NamedAgentPoolProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 kubernetes_version: str,
+                 count: Optional[int] = None,
+                 enable_auto_scaling: Optional[bool] = None,
+                 max_count: Optional[int] = None,
+                 max_pods: Optional[int] = None,
+                 min_count: Optional[int] = None,
+                 name: Optional[str] = None,
+                 node_labels: Optional[Mapping[str, str]] = None,
+                 node_taints: Optional[Sequence[str]] = None,
+                 os_sku: Optional[str] = None,
+                 os_type: Optional[str] = None,
+                 vm_size: Optional[str] = None):
+        """
+        Profile of the default agent pool along with a name parameter
+        :param str kubernetes_version: Version of Kubernetes in use by the agent pool. This is inherited from the kubernetesVersion of the provisioned cluster.
+        :param int count: Number of nodes in the agent pool. The default value is 1.
+        :param bool enable_auto_scaling: Whether to enable auto-scaler. Default value is false
+        :param int max_count: The maximum number of nodes for auto-scaling
+        :param int max_pods: The maximum number of pods that can run on a node.
+        :param int min_count: The minimum number of nodes for auto-scaling
+        :param str name: Unique name of the default agent pool in the context of the provisioned cluster. Default value is <clusterName>-nodepool1
+        :param Mapping[str, str] node_labels: The node labels to be persisted across all nodes in agent pool.
+        :param Sequence[str] node_taints: Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
+        :param str os_sku: Specifies the OS SKU used by the agent pool. The default is CBLMariner if OSType is Linux. The default is Windows2019 when OSType is Windows.
+        :param str os_type: OSType to be used to specify OS type for the VMs. Choose from Linux and Windows. Default to Linux. Possible values include: 'Linux', 'Windows'
+        :param str vm_size: The VM sku size of the agent pool node VMs.
+        """
+        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
+        if count is None:
+            count = 1
+        if count is not None:
+            pulumi.set(__self__, "count", count)
+        if enable_auto_scaling is None:
+            enable_auto_scaling = False
+        if enable_auto_scaling is not None:
+            pulumi.set(__self__, "enable_auto_scaling", enable_auto_scaling)
+        if max_count is not None:
+            pulumi.set(__self__, "max_count", max_count)
+        if max_pods is not None:
+            pulumi.set(__self__, "max_pods", max_pods)
+        if min_count is not None:
+            pulumi.set(__self__, "min_count", min_count)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if node_labels is not None:
+            pulumi.set(__self__, "node_labels", node_labels)
+        if node_taints is not None:
+            pulumi.set(__self__, "node_taints", node_taints)
+        if os_sku is not None:
+            pulumi.set(__self__, "os_sku", os_sku)
+        if os_type is not None:
+            pulumi.set(__self__, "os_type", os_type)
+        if vm_size is not None:
+            pulumi.set(__self__, "vm_size", vm_size)
+
+    @property
+    @pulumi.getter(name="kubernetesVersion")
+    def kubernetes_version(self) -> str:
+        """
+        Version of Kubernetes in use by the agent pool. This is inherited from the kubernetesVersion of the provisioned cluster.
+        """
+        return pulumi.get(self, "kubernetes_version")
+
+    @property
+    @pulumi.getter
+    def count(self) -> Optional[int]:
+        """
+        Number of nodes in the agent pool. The default value is 1.
+        """
+        return pulumi.get(self, "count")
+
+    @property
+    @pulumi.getter(name="enableAutoScaling")
+    def enable_auto_scaling(self) -> Optional[bool]:
+        """
+        Whether to enable auto-scaler. Default value is false
+        """
+        return pulumi.get(self, "enable_auto_scaling")
+
+    @property
+    @pulumi.getter(name="maxCount")
+    def max_count(self) -> Optional[int]:
+        """
+        The maximum number of nodes for auto-scaling
+        """
+        return pulumi.get(self, "max_count")
+
+    @property
+    @pulumi.getter(name="maxPods")
+    def max_pods(self) -> Optional[int]:
+        """
+        The maximum number of pods that can run on a node.
+        """
+        return pulumi.get(self, "max_pods")
+
+    @property
+    @pulumi.getter(name="minCount")
+    def min_count(self) -> Optional[int]:
+        """
+        The minimum number of nodes for auto-scaling
+        """
+        return pulumi.get(self, "min_count")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Unique name of the default agent pool in the context of the provisioned cluster. Default value is <clusterName>-nodepool1
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="nodeLabels")
+    def node_labels(self) -> Optional[Mapping[str, str]]:
+        """
+        The node labels to be persisted across all nodes in agent pool.
+        """
+        return pulumi.get(self, "node_labels")
+
+    @property
+    @pulumi.getter(name="nodeTaints")
+    def node_taints(self) -> Optional[Sequence[str]]:
+        """
+        Taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
+        """
+        return pulumi.get(self, "node_taints")
+
+    @property
+    @pulumi.getter(name="osSKU")
+    def os_sku(self) -> Optional[str]:
+        """
+        Specifies the OS SKU used by the agent pool. The default is CBLMariner if OSType is Linux. The default is Windows2019 when OSType is Windows.
+        """
+        return pulumi.get(self, "os_sku")
+
+    @property
+    @pulumi.getter(name="osType")
+    def os_type(self) -> Optional[str]:
+        """
+        OSType to be used to specify OS type for the VMs. Choose from Linux and Windows. Default to Linux. Possible values include: 'Linux', 'Windows'
+        """
+        return pulumi.get(self, "os_type")
+
+    @property
+    @pulumi.getter(name="vmSize")
+    def vm_size(self) -> Optional[str]:
+        """
+        The VM sku size of the agent pool node VMs.
+        """
+        return pulumi.get(self, "vm_size")
+
+
+@pulumi.output_type
+class NetworkProfileResponse(dict):
+    """
+    The network configuration profile for the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "loadBalancerProfile":
+            suggest = "load_balancer_profile"
+        elif key == "networkPolicy":
+            suggest = "network_policy"
+        elif key == "podCidr":
+            suggest = "pod_cidr"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 load_balancer_profile: Optional['outputs.NetworkProfileResponseLoadBalancerProfile'] = None,
+                 network_policy: Optional[str] = None,
+                 pod_cidr: Optional[str] = None):
+        """
+        The network configuration profile for the provisioned cluster.
+        :param 'NetworkProfileResponseLoadBalancerProfile' load_balancer_profile: Profile of the HA Proxy load balancer.
+        :param str network_policy: Network policy used for building Kubernetes network. Possible values include: 'calico'.
+        :param str pod_cidr: A CIDR notation IP Address range from which to assign pod IPs.
+        """
+        if load_balancer_profile is not None:
+            pulumi.set(__self__, "load_balancer_profile", load_balancer_profile)
+        if network_policy is None:
+            network_policy = 'calico'
+        if network_policy is not None:
+            pulumi.set(__self__, "network_policy", network_policy)
+        if pod_cidr is not None:
+            pulumi.set(__self__, "pod_cidr", pod_cidr)
+
+    @property
+    @pulumi.getter(name="loadBalancerProfile")
+    def load_balancer_profile(self) -> Optional['outputs.NetworkProfileResponseLoadBalancerProfile']:
+        """
+        Profile of the HA Proxy load balancer.
+        """
+        return pulumi.get(self, "load_balancer_profile")
+
+    @property
+    @pulumi.getter(name="networkPolicy")
+    def network_policy(self) -> Optional[str]:
+        """
+        Network policy used for building Kubernetes network. Possible values include: 'calico'.
+        """
+        return pulumi.get(self, "network_policy")
+
+    @property
+    @pulumi.getter(name="podCidr")
+    def pod_cidr(self) -> Optional[str]:
+        """
+        A CIDR notation IP Address range from which to assign pod IPs.
+        """
+        return pulumi.get(self, "pod_cidr")
+
+
+@pulumi.output_type
+class NetworkProfileResponseLoadBalancerProfile(dict):
+    """
+    Profile of the HA Proxy load balancer.
+    """
+    def __init__(__self__, *,
+                 count: Optional[int] = None):
+        """
+        Profile of the HA Proxy load balancer.
+        :param int count: Number of HA Proxy load balancer VMs. The default value is 0.
+        """
+        if count is None:
+            count = 0
+        if count is not None:
+            pulumi.set(__self__, "count", count)
+
+    @property
+    @pulumi.getter
+    def count(self) -> Optional[int]:
+        """
+        Number of HA Proxy load balancer VMs. The default value is 0.
+        """
+        return pulumi.get(self, "count")
+
+
+@pulumi.output_type
+class ProvisionedClusterLicenseProfileResponse(dict):
+    """
+    The license profile of the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "azureHybridBenefit":
+            suggest = "azure_hybrid_benefit"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProvisionedClusterLicenseProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProvisionedClusterLicenseProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProvisionedClusterLicenseProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 azure_hybrid_benefit: Optional[str] = None):
+        """
+        The license profile of the provisioned cluster.
+        :param str azure_hybrid_benefit: Indicates whether Azure Hybrid Benefit is opted in. Default value is false
+        """
+        if azure_hybrid_benefit is None:
+            azure_hybrid_benefit = 'NotApplicable'
+        if azure_hybrid_benefit is not None:
+            pulumi.set(__self__, "azure_hybrid_benefit", azure_hybrid_benefit)
+
+    @property
+    @pulumi.getter(name="azureHybridBenefit")
+    def azure_hybrid_benefit(self) -> Optional[str]:
+        """
+        Indicates whether Azure Hybrid Benefit is opted in. Default value is false
+        """
+        return pulumi.get(self, "azure_hybrid_benefit")
+
+
+@pulumi.output_type
+class ProvisionedClusterPropertiesResponse(dict):
+    """
+    Properties of the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "agentPoolProfiles":
+            suggest = "agent_pool_profiles"
+        elif key == "autoScalerProfile":
+            suggest = "auto_scaler_profile"
+        elif key == "cloudProviderProfile":
+            suggest = "cloud_provider_profile"
+        elif key == "clusterVMAccessProfile":
+            suggest = "cluster_vm_access_profile"
+        elif key == "controlPlane":
+            suggest = "control_plane"
+        elif key == "kubernetesVersion":
+            suggest = "kubernetes_version"
+        elif key == "licenseProfile":
+            suggest = "license_profile"
+        elif key == "linuxProfile":
+            suggest = "linux_profile"
+        elif key == "networkProfile":
+            suggest = "network_profile"
+        elif key == "storageProfile":
+            suggest = "storage_profile"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProvisionedClusterPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProvisionedClusterPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProvisionedClusterPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: str,
+                 status: 'outputs.ProvisionedClusterPropertiesResponseStatus',
+                 agent_pool_profiles: Optional[Sequence['outputs.NamedAgentPoolProfileResponse']] = None,
+                 auto_scaler_profile: Optional['outputs.ProvisionedClusterPropertiesResponseAutoScalerProfile'] = None,
+                 cloud_provider_profile: Optional['outputs.CloudProviderProfileResponse'] = None,
+                 cluster_vm_access_profile: Optional['outputs.ClusterVMAccessProfileResponse'] = None,
+                 control_plane: Optional['outputs.ControlPlaneProfileResponse'] = None,
+                 kubernetes_version: Optional[str] = None,
+                 license_profile: Optional['outputs.ProvisionedClusterLicenseProfileResponse'] = None,
+                 linux_profile: Optional['outputs.LinuxProfilePropertiesResponse'] = None,
+                 network_profile: Optional['outputs.NetworkProfileResponse'] = None,
+                 storage_profile: Optional['outputs.StorageProfileResponse'] = None):
+        """
+        Properties of the provisioned cluster.
+        :param str provisioning_state: The status of the latest long running operation for the provisioned cluster.
+        :param 'ProvisionedClusterPropertiesResponseStatus' status: The observed status of the provisioned cluster.
+        :param Sequence['NamedAgentPoolProfileResponse'] agent_pool_profiles: The agent pool properties for the provisioned cluster.
+        :param 'ProvisionedClusterPropertiesResponseAutoScalerProfile' auto_scaler_profile: Parameters to be applied to the cluster-autoscaler when auto scaling is enabled for the provisioned cluster.
+        :param 'CloudProviderProfileResponse' cloud_provider_profile: The profile for the underlying cloud infrastructure provider for the provisioned cluster.
+        :param 'ClusterVMAccessProfileResponse' cluster_vm_access_profile: The SSH restricted access profile for the VMs in the provisioned cluster.
+        :param 'ControlPlaneProfileResponse' control_plane: The profile for control plane of the provisioned cluster.
+        :param str kubernetes_version: The version of Kubernetes in use by the provisioned cluster.
+        :param 'ProvisionedClusterLicenseProfileResponse' license_profile: The license profile of the provisioned cluster.
+        :param 'LinuxProfilePropertiesResponse' linux_profile: The profile for Linux VMs in the provisioned cluster.
+        :param 'NetworkProfileResponse' network_profile: The network configuration profile for the provisioned cluster.
+        :param 'StorageProfileResponse' storage_profile: The storage configuration profile for the provisioned cluster.
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "status", status)
+        if agent_pool_profiles is not None:
+            pulumi.set(__self__, "agent_pool_profiles", agent_pool_profiles)
+        if auto_scaler_profile is not None:
+            pulumi.set(__self__, "auto_scaler_profile", auto_scaler_profile)
+        if cloud_provider_profile is not None:
+            pulumi.set(__self__, "cloud_provider_profile", cloud_provider_profile)
+        if cluster_vm_access_profile is not None:
+            pulumi.set(__self__, "cluster_vm_access_profile", cluster_vm_access_profile)
+        if control_plane is not None:
+            pulumi.set(__self__, "control_plane", control_plane)
+        if kubernetes_version is not None:
+            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
+        if license_profile is not None:
+            pulumi.set(__self__, "license_profile", license_profile)
+        if linux_profile is not None:
+            pulumi.set(__self__, "linux_profile", linux_profile)
+        if network_profile is not None:
+            pulumi.set(__self__, "network_profile", network_profile)
+        if storage_profile is not None:
+            pulumi.set(__self__, "storage_profile", storage_profile)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The status of the latest long running operation for the provisioned cluster.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.ProvisionedClusterPropertiesResponseStatus':
+        """
+        The observed status of the provisioned cluster.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="agentPoolProfiles")
+    def agent_pool_profiles(self) -> Optional[Sequence['outputs.NamedAgentPoolProfileResponse']]:
+        """
+        The agent pool properties for the provisioned cluster.
+        """
+        return pulumi.get(self, "agent_pool_profiles")
+
+    @property
+    @pulumi.getter(name="autoScalerProfile")
+    def auto_scaler_profile(self) -> Optional['outputs.ProvisionedClusterPropertiesResponseAutoScalerProfile']:
+        """
+        Parameters to be applied to the cluster-autoscaler when auto scaling is enabled for the provisioned cluster.
+        """
+        return pulumi.get(self, "auto_scaler_profile")
+
+    @property
+    @pulumi.getter(name="cloudProviderProfile")
+    def cloud_provider_profile(self) -> Optional['outputs.CloudProviderProfileResponse']:
+        """
+        The profile for the underlying cloud infrastructure provider for the provisioned cluster.
+        """
+        return pulumi.get(self, "cloud_provider_profile")
+
+    @property
+    @pulumi.getter(name="clusterVMAccessProfile")
+    def cluster_vm_access_profile(self) -> Optional['outputs.ClusterVMAccessProfileResponse']:
+        """
+        The SSH restricted access profile for the VMs in the provisioned cluster.
+        """
+        return pulumi.get(self, "cluster_vm_access_profile")
+
+    @property
+    @pulumi.getter(name="controlPlane")
+    def control_plane(self) -> Optional['outputs.ControlPlaneProfileResponse']:
+        """
+        The profile for control plane of the provisioned cluster.
+        """
+        return pulumi.get(self, "control_plane")
+
+    @property
+    @pulumi.getter(name="kubernetesVersion")
+    def kubernetes_version(self) -> Optional[str]:
+        """
+        The version of Kubernetes in use by the provisioned cluster.
+        """
+        return pulumi.get(self, "kubernetes_version")
+
+    @property
+    @pulumi.getter(name="licenseProfile")
+    def license_profile(self) -> Optional['outputs.ProvisionedClusterLicenseProfileResponse']:
+        """
+        The license profile of the provisioned cluster.
+        """
+        return pulumi.get(self, "license_profile")
+
+    @property
+    @pulumi.getter(name="linuxProfile")
+    def linux_profile(self) -> Optional['outputs.LinuxProfilePropertiesResponse']:
+        """
+        The profile for Linux VMs in the provisioned cluster.
+        """
+        return pulumi.get(self, "linux_profile")
+
+    @property
+    @pulumi.getter(name="networkProfile")
+    def network_profile(self) -> Optional['outputs.NetworkProfileResponse']:
+        """
+        The network configuration profile for the provisioned cluster.
+        """
+        return pulumi.get(self, "network_profile")
+
+    @property
+    @pulumi.getter(name="storageProfile")
+    def storage_profile(self) -> Optional['outputs.StorageProfileResponse']:
+        """
+        The storage configuration profile for the provisioned cluster.
+        """
+        return pulumi.get(self, "storage_profile")
+
+
+@pulumi.output_type
+class ProvisionedClusterPropertiesResponseAutoScalerProfile(dict):
+    """
+    Parameters to be applied to the cluster-autoscaler when auto scaling is enabled for the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "balanceSimilarNodeGroups":
+            suggest = "balance_similar_node_groups"
+        elif key == "maxEmptyBulkDelete":
+            suggest = "max_empty_bulk_delete"
+        elif key == "maxGracefulTerminationSec":
+            suggest = "max_graceful_termination_sec"
+        elif key == "maxNodeProvisionTime":
+            suggest = "max_node_provision_time"
+        elif key == "maxTotalUnreadyPercentage":
+            suggest = "max_total_unready_percentage"
+        elif key == "newPodScaleUpDelay":
+            suggest = "new_pod_scale_up_delay"
+        elif key == "okTotalUnreadyCount":
+            suggest = "ok_total_unready_count"
+        elif key == "scaleDownDelayAfterAdd":
+            suggest = "scale_down_delay_after_add"
+        elif key == "scaleDownDelayAfterDelete":
+            suggest = "scale_down_delay_after_delete"
+        elif key == "scaleDownDelayAfterFailure":
+            suggest = "scale_down_delay_after_failure"
+        elif key == "scaleDownUnneededTime":
+            suggest = "scale_down_unneeded_time"
+        elif key == "scaleDownUnreadyTime":
+            suggest = "scale_down_unready_time"
+        elif key == "scaleDownUtilizationThreshold":
+            suggest = "scale_down_utilization_threshold"
+        elif key == "scanInterval":
+            suggest = "scan_interval"
+        elif key == "skipNodesWithLocalStorage":
+            suggest = "skip_nodes_with_local_storage"
+        elif key == "skipNodesWithSystemPods":
+            suggest = "skip_nodes_with_system_pods"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProvisionedClusterPropertiesResponseAutoScalerProfile. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProvisionedClusterPropertiesResponseAutoScalerProfile.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProvisionedClusterPropertiesResponseAutoScalerProfile.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 balance_similar_node_groups: Optional[str] = None,
+                 expander: Optional[str] = None,
+                 max_empty_bulk_delete: Optional[str] = None,
+                 max_graceful_termination_sec: Optional[str] = None,
+                 max_node_provision_time: Optional[str] = None,
+                 max_total_unready_percentage: Optional[str] = None,
+                 new_pod_scale_up_delay: Optional[str] = None,
+                 ok_total_unready_count: Optional[str] = None,
+                 scale_down_delay_after_add: Optional[str] = None,
+                 scale_down_delay_after_delete: Optional[str] = None,
+                 scale_down_delay_after_failure: Optional[str] = None,
+                 scale_down_unneeded_time: Optional[str] = None,
+                 scale_down_unready_time: Optional[str] = None,
+                 scale_down_utilization_threshold: Optional[str] = None,
+                 scan_interval: Optional[str] = None,
+                 skip_nodes_with_local_storage: Optional[str] = None,
+                 skip_nodes_with_system_pods: Optional[str] = None):
+        """
+        Parameters to be applied to the cluster-autoscaler when auto scaling is enabled for the provisioned cluster.
+        :param str balance_similar_node_groups: Valid values are 'true' and 'false'
+        :param str expander: If not specified, the default is 'random'. See [expanders](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders) for more information.
+        :param str max_empty_bulk_delete: The default is 10.
+        :param str max_graceful_termination_sec: The default is 600.
+        :param str max_node_provision_time: The default is '15m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str max_total_unready_percentage: The default is 45. The maximum is 100 and the minimum is 0.
+        :param str new_pod_scale_up_delay: For scenarios like burst/batch scale where you don't want CA to act before the kubernetes scheduler could schedule all the pods, you can tell CA to ignore unscheduled pods before they're a certain age. The default is '0s'. Values must be an integer followed by a unit ('s' for seconds, 'm' for minutes, 'h' for hours, etc).
+        :param str ok_total_unready_count: This must be an integer. The default is 3.
+        :param str scale_down_delay_after_add: The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str scale_down_delay_after_delete: The default is the scan-interval. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str scale_down_delay_after_failure: The default is '3m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str scale_down_unneeded_time: The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str scale_down_unready_time: The default is '20m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        :param str scale_down_utilization_threshold: The default is '0.5'.
+        :param str scan_interval: The default is '10'. Values must be an integer number of seconds.
+        :param str skip_nodes_with_local_storage: The default is true.
+        :param str skip_nodes_with_system_pods: The default is true.
+        """
+        if balance_similar_node_groups is not None:
+            pulumi.set(__self__, "balance_similar_node_groups", balance_similar_node_groups)
+        if expander is not None:
+            pulumi.set(__self__, "expander", expander)
+        if max_empty_bulk_delete is not None:
+            pulumi.set(__self__, "max_empty_bulk_delete", max_empty_bulk_delete)
+        if max_graceful_termination_sec is not None:
+            pulumi.set(__self__, "max_graceful_termination_sec", max_graceful_termination_sec)
+        if max_node_provision_time is not None:
+            pulumi.set(__self__, "max_node_provision_time", max_node_provision_time)
+        if max_total_unready_percentage is not None:
+            pulumi.set(__self__, "max_total_unready_percentage", max_total_unready_percentage)
+        if new_pod_scale_up_delay is not None:
+            pulumi.set(__self__, "new_pod_scale_up_delay", new_pod_scale_up_delay)
+        if ok_total_unready_count is not None:
+            pulumi.set(__self__, "ok_total_unready_count", ok_total_unready_count)
+        if scale_down_delay_after_add is not None:
+            pulumi.set(__self__, "scale_down_delay_after_add", scale_down_delay_after_add)
+        if scale_down_delay_after_delete is not None:
+            pulumi.set(__self__, "scale_down_delay_after_delete", scale_down_delay_after_delete)
+        if scale_down_delay_after_failure is not None:
+            pulumi.set(__self__, "scale_down_delay_after_failure", scale_down_delay_after_failure)
+        if scale_down_unneeded_time is not None:
+            pulumi.set(__self__, "scale_down_unneeded_time", scale_down_unneeded_time)
+        if scale_down_unready_time is not None:
+            pulumi.set(__self__, "scale_down_unready_time", scale_down_unready_time)
+        if scale_down_utilization_threshold is not None:
+            pulumi.set(__self__, "scale_down_utilization_threshold", scale_down_utilization_threshold)
+        if scan_interval is not None:
+            pulumi.set(__self__, "scan_interval", scan_interval)
+        if skip_nodes_with_local_storage is not None:
+            pulumi.set(__self__, "skip_nodes_with_local_storage", skip_nodes_with_local_storage)
+        if skip_nodes_with_system_pods is not None:
+            pulumi.set(__self__, "skip_nodes_with_system_pods", skip_nodes_with_system_pods)
+
+    @property
+    @pulumi.getter(name="balanceSimilarNodeGroups")
+    def balance_similar_node_groups(self) -> Optional[str]:
+        """
+        Valid values are 'true' and 'false'
+        """
+        return pulumi.get(self, "balance_similar_node_groups")
+
+    @property
+    @pulumi.getter
+    def expander(self) -> Optional[str]:
+        """
+        If not specified, the default is 'random'. See [expanders](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders) for more information.
+        """
+        return pulumi.get(self, "expander")
+
+    @property
+    @pulumi.getter(name="maxEmptyBulkDelete")
+    def max_empty_bulk_delete(self) -> Optional[str]:
+        """
+        The default is 10.
+        """
+        return pulumi.get(self, "max_empty_bulk_delete")
+
+    @property
+    @pulumi.getter(name="maxGracefulTerminationSec")
+    def max_graceful_termination_sec(self) -> Optional[str]:
+        """
+        The default is 600.
+        """
+        return pulumi.get(self, "max_graceful_termination_sec")
+
+    @property
+    @pulumi.getter(name="maxNodeProvisionTime")
+    def max_node_provision_time(self) -> Optional[str]:
+        """
+        The default is '15m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "max_node_provision_time")
+
+    @property
+    @pulumi.getter(name="maxTotalUnreadyPercentage")
+    def max_total_unready_percentage(self) -> Optional[str]:
+        """
+        The default is 45. The maximum is 100 and the minimum is 0.
+        """
+        return pulumi.get(self, "max_total_unready_percentage")
+
+    @property
+    @pulumi.getter(name="newPodScaleUpDelay")
+    def new_pod_scale_up_delay(self) -> Optional[str]:
+        """
+        For scenarios like burst/batch scale where you don't want CA to act before the kubernetes scheduler could schedule all the pods, you can tell CA to ignore unscheduled pods before they're a certain age. The default is '0s'. Values must be an integer followed by a unit ('s' for seconds, 'm' for minutes, 'h' for hours, etc).
+        """
+        return pulumi.get(self, "new_pod_scale_up_delay")
+
+    @property
+    @pulumi.getter(name="okTotalUnreadyCount")
+    def ok_total_unready_count(self) -> Optional[str]:
+        """
+        This must be an integer. The default is 3.
+        """
+        return pulumi.get(self, "ok_total_unready_count")
+
+    @property
+    @pulumi.getter(name="scaleDownDelayAfterAdd")
+    def scale_down_delay_after_add(self) -> Optional[str]:
+        """
+        The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "scale_down_delay_after_add")
+
+    @property
+    @pulumi.getter(name="scaleDownDelayAfterDelete")
+    def scale_down_delay_after_delete(self) -> Optional[str]:
+        """
+        The default is the scan-interval. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "scale_down_delay_after_delete")
+
+    @property
+    @pulumi.getter(name="scaleDownDelayAfterFailure")
+    def scale_down_delay_after_failure(self) -> Optional[str]:
+        """
+        The default is '3m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "scale_down_delay_after_failure")
+
+    @property
+    @pulumi.getter(name="scaleDownUnneededTime")
+    def scale_down_unneeded_time(self) -> Optional[str]:
+        """
+        The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "scale_down_unneeded_time")
+
+    @property
+    @pulumi.getter(name="scaleDownUnreadyTime")
+    def scale_down_unready_time(self) -> Optional[str]:
+        """
+        The default is '20m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
+        """
+        return pulumi.get(self, "scale_down_unready_time")
+
+    @property
+    @pulumi.getter(name="scaleDownUtilizationThreshold")
+    def scale_down_utilization_threshold(self) -> Optional[str]:
+        """
+        The default is '0.5'.
+        """
+        return pulumi.get(self, "scale_down_utilization_threshold")
+
+    @property
+    @pulumi.getter(name="scanInterval")
+    def scan_interval(self) -> Optional[str]:
+        """
+        The default is '10'. Values must be an integer number of seconds.
+        """
+        return pulumi.get(self, "scan_interval")
+
+    @property
+    @pulumi.getter(name="skipNodesWithLocalStorage")
+    def skip_nodes_with_local_storage(self) -> Optional[str]:
+        """
+        The default is true.
+        """
+        return pulumi.get(self, "skip_nodes_with_local_storage")
+
+    @property
+    @pulumi.getter(name="skipNodesWithSystemPods")
+    def skip_nodes_with_system_pods(self) -> Optional[str]:
+        """
+        The default is true.
+        """
+        return pulumi.get(self, "skip_nodes_with_system_pods")
+
+
+@pulumi.output_type
+class ProvisionedClusterPropertiesResponseStatus(dict):
+    """
+    The observed status of the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "currentState":
+            suggest = "current_state"
+        elif key == "controlPlaneStatus":
+            suggest = "control_plane_status"
+        elif key == "errorMessage":
+            suggest = "error_message"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProvisionedClusterPropertiesResponseStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProvisionedClusterPropertiesResponseStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProvisionedClusterPropertiesResponseStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 current_state: str,
+                 control_plane_status: Optional[Sequence['outputs.AddonStatusProfileResponse']] = None,
+                 error_message: Optional[str] = None):
+        """
+        The observed status of the provisioned cluster.
+        :param str current_state: The current state of the provisioned cluster.
+        :param Sequence['AddonStatusProfileResponse'] control_plane_status: The detailed status of the provisioned cluster components including addons.
+        :param str error_message: Error messages during a provisioned cluster operation or steady state.
+        """
+        pulumi.set(__self__, "current_state", current_state)
+        if control_plane_status is not None:
+            pulumi.set(__self__, "control_plane_status", control_plane_status)
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+
+    @property
+    @pulumi.getter(name="currentState")
+    def current_state(self) -> str:
+        """
+        The current state of the provisioned cluster.
+        """
+        return pulumi.get(self, "current_state")
+
+    @property
+    @pulumi.getter(name="controlPlaneStatus")
+    def control_plane_status(self) -> Optional[Sequence['outputs.AddonStatusProfileResponse']]:
+        """
+        The detailed status of the provisioned cluster components including addons.
+        """
+        return pulumi.get(self, "control_plane_status")
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[str]:
+        """
+        Error messages during a provisioned cluster operation or steady state.
+        """
+        return pulumi.get(self, "error_message")
+
+
+@pulumi.output_type
+class StorageProfileNfsCSIDriverResponse(dict):
+    """
+    NFS CSI Driver settings for the storage profile.
+    """
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None):
+        """
+        NFS CSI Driver settings for the storage profile.
+        :param bool enabled: Indicates whether to enable NFS CSI Driver. The default value is true.
+        """
+        if enabled is None:
+            enabled = True
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Indicates whether to enable NFS CSI Driver. The default value is true.
+        """
+        return pulumi.get(self, "enabled")
+
+
+@pulumi.output_type
+class StorageProfileResponse(dict):
+    """
+    The storage configuration profile for the provisioned cluster.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nfsCsiDriver":
+            suggest = "nfs_csi_driver"
+        elif key == "smbCsiDriver":
+            suggest = "smb_csi_driver"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StorageProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StorageProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StorageProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 nfs_csi_driver: Optional['outputs.StorageProfileNfsCSIDriverResponse'] = None,
+                 smb_csi_driver: Optional['outputs.StorageProfileSmbCSIDriverResponse'] = None):
+        """
+        The storage configuration profile for the provisioned cluster.
+        :param 'StorageProfileNfsCSIDriverResponse' nfs_csi_driver: NFS CSI Driver settings for the storage profile.
+        :param 'StorageProfileSmbCSIDriverResponse' smb_csi_driver: SMB CSI Driver settings for the storage profile.
+        """
+        if nfs_csi_driver is not None:
+            pulumi.set(__self__, "nfs_csi_driver", nfs_csi_driver)
+        if smb_csi_driver is not None:
+            pulumi.set(__self__, "smb_csi_driver", smb_csi_driver)
+
+    @property
+    @pulumi.getter(name="nfsCsiDriver")
+    def nfs_csi_driver(self) -> Optional['outputs.StorageProfileNfsCSIDriverResponse']:
+        """
+        NFS CSI Driver settings for the storage profile.
+        """
+        return pulumi.get(self, "nfs_csi_driver")
+
+    @property
+    @pulumi.getter(name="smbCsiDriver")
+    def smb_csi_driver(self) -> Optional['outputs.StorageProfileSmbCSIDriverResponse']:
+        """
+        SMB CSI Driver settings for the storage profile.
+        """
+        return pulumi.get(self, "smb_csi_driver")
+
+
+@pulumi.output_type
+class StorageProfileSmbCSIDriverResponse(dict):
+    """
+    SMB CSI Driver settings for the storage profile.
+    """
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None):
+        """
+        SMB CSI Driver settings for the storage profile.
+        :param bool enabled: Indicates whether to enable SMB CSI Driver. The default value is true.
+        """
+        if enabled is None:
+            enabled = True
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Indicates whether to enable SMB CSI Driver. The default value is true.
+        """
+        return pulumi.get(self, "enabled")
+
+
+@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 VirtualNetworkPropertiesResponse(dict):
+    """
+    Properties of the virtual network resource
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "dnsServers":
+            suggest = "dns_servers"
+        elif key == "infraVnetProfile":
+            suggest = "infra_vnet_profile"
+        elif key == "ipAddressPrefix":
+            suggest = "ip_address_prefix"
+        elif key == "vipPool":
+            suggest = "vip_pool"
+        elif key == "vlanID":
+            suggest = "vlan_id"
+        elif key == "vmipPool":
+            suggest = "vmip_pool"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: str,
+                 status: 'outputs.VirtualNetworkPropertiesResponseStatus',
+                 dns_servers: Optional[Sequence[str]] = None,
+                 gateway: Optional[str] = None,
+                 infra_vnet_profile: Optional['outputs.VirtualNetworkPropertiesResponseInfraVnetProfile'] = None,
+                 ip_address_prefix: Optional[str] = None,
+                 vip_pool: Optional[Sequence['outputs.VirtualNetworkPropertiesResponseVipPool']] = None,
+                 vlan_id: Optional[int] = None,
+                 vmip_pool: Optional[Sequence['outputs.VirtualNetworkPropertiesResponseVmipPool']] = None):
+        """
+        Properties of the virtual network resource
+        :param 'VirtualNetworkPropertiesResponseStatus' status: Status of the virtual network resource
+        :param Sequence[str] dns_servers: List of DNS server IP Addresses associated with the network
+        :param str gateway: IP Address of the Gateway associated with the network
+        :param str ip_address_prefix: IP Address Prefix of the network
+        :param Sequence['VirtualNetworkPropertiesResponseVipPool'] vip_pool: Range of IP Addresses for Kubernetes API Server and services if using HA Proxy load balancer
+        :param int vlan_id: VLAN Id used by the network
+        :param Sequence['VirtualNetworkPropertiesResponseVmipPool'] vmip_pool: Range of IP Addresses for Kubernetes node VMs
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "status", status)
+        if dns_servers is not None:
+            pulumi.set(__self__, "dns_servers", dns_servers)
+        if gateway is not None:
+            pulumi.set(__self__, "gateway", gateway)
+        if infra_vnet_profile is not None:
+            pulumi.set(__self__, "infra_vnet_profile", infra_vnet_profile)
+        if ip_address_prefix is not None:
+            pulumi.set(__self__, "ip_address_prefix", ip_address_prefix)
+        if vip_pool is not None:
+            pulumi.set(__self__, "vip_pool", vip_pool)
+        if vlan_id is not None:
+            pulumi.set(__self__, "vlan_id", vlan_id)
+        if vmip_pool is not None:
+            pulumi.set(__self__, "vmip_pool", vmip_pool)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def status(self) -> 'outputs.VirtualNetworkPropertiesResponseStatus':
+        """
+        Status of the virtual network resource
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="dnsServers")
+    def dns_servers(self) -> Optional[Sequence[str]]:
+        """
+        List of DNS server IP Addresses associated with the network
+        """
+        return pulumi.get(self, "dns_servers")
+
+    @property
+    @pulumi.getter
+    def gateway(self) -> Optional[str]:
+        """
+        IP Address of the Gateway associated with the network
+        """
+        return pulumi.get(self, "gateway")
+
+    @property
+    @pulumi.getter(name="infraVnetProfile")
+    def infra_vnet_profile(self) -> Optional['outputs.VirtualNetworkPropertiesResponseInfraVnetProfile']:
+        return pulumi.get(self, "infra_vnet_profile")
+
+    @property
+    @pulumi.getter(name="ipAddressPrefix")
+    def ip_address_prefix(self) -> Optional[str]:
+        """
+        IP Address Prefix of the network
+        """
+        return pulumi.get(self, "ip_address_prefix")
+
+    @property
+    @pulumi.getter(name="vipPool")
+    def vip_pool(self) -> Optional[Sequence['outputs.VirtualNetworkPropertiesResponseVipPool']]:
+        """
+        Range of IP Addresses for Kubernetes API Server and services if using HA Proxy load balancer
+        """
+        return pulumi.get(self, "vip_pool")
+
+    @property
+    @pulumi.getter(name="vlanID")
+    def vlan_id(self) -> Optional[int]:
+        """
+        VLAN Id used by the network
+        """
+        return pulumi.get(self, "vlan_id")
+
+    @property
+    @pulumi.getter(name="vmipPool")
+    def vmip_pool(self) -> Optional[Sequence['outputs.VirtualNetworkPropertiesResponseVmipPool']]:
+        """
+        Range of IP Addresses for Kubernetes node VMs
+        """
+        return pulumi.get(self, "vmip_pool")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseError(dict):
+    """
+    The error if any from the operation.
+    """
+    def __init__(__self__, *,
+                 code: Optional[str] = None,
+                 message: Optional[str] = None):
+        """
+        The error if any from the operation.
+        :param str code: The error code from the operation.
+        :param str message: The error message from the operation.
+        """
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[str]:
+        """
+        The error code from the operation.
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[str]:
+        """
+        The error message from the operation.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseHci(dict):
+    """
+    Infrastructure network profile for HCI platform
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mocGroup":
+            suggest = "moc_group"
+        elif key == "mocLocation":
+            suggest = "moc_location"
+        elif key == "mocVnetName":
+            suggest = "moc_vnet_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponseHci. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponseHci.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponseHci.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 moc_group: Optional[str] = None,
+                 moc_location: Optional[str] = None,
+                 moc_vnet_name: Optional[str] = None):
+        """
+        Infrastructure network profile for HCI platform
+        :param str moc_group: Group in MOC(Microsoft On-premises Cloud)
+        :param str moc_location: Location in MOC(Microsoft On-premises Cloud)
+        :param str moc_vnet_name: Virtual Network name in MOC(Microsoft On-premises Cloud)
+        """
+        if moc_group is not None:
+            pulumi.set(__self__, "moc_group", moc_group)
+        if moc_location is not None:
+            pulumi.set(__self__, "moc_location", moc_location)
+        if moc_vnet_name is not None:
+            pulumi.set(__self__, "moc_vnet_name", moc_vnet_name)
+
+    @property
+    @pulumi.getter(name="mocGroup")
+    def moc_group(self) -> Optional[str]:
+        """
+        Group in MOC(Microsoft On-premises Cloud)
+        """
+        return pulumi.get(self, "moc_group")
+
+    @property
+    @pulumi.getter(name="mocLocation")
+    def moc_location(self) -> Optional[str]:
+        """
+        Location in MOC(Microsoft On-premises Cloud)
+        """
+        return pulumi.get(self, "moc_location")
+
+    @property
+    @pulumi.getter(name="mocVnetName")
+    def moc_vnet_name(self) -> Optional[str]:
+        """
+        Virtual Network name in MOC(Microsoft On-premises Cloud)
+        """
+        return pulumi.get(self, "moc_vnet_name")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseInfraVnetProfile(dict):
+    def __init__(__self__, *,
+                 hci: Optional['outputs.VirtualNetworkPropertiesResponseHci'] = None):
+        """
+        :param 'VirtualNetworkPropertiesResponseHci' hci: Infrastructure network profile for HCI platform
+        """
+        if hci is not None:
+            pulumi.set(__self__, "hci", hci)
+
+    @property
+    @pulumi.getter
+    def hci(self) -> Optional['outputs.VirtualNetworkPropertiesResponseHci']:
+        """
+        Infrastructure network profile for HCI platform
+        """
+        return pulumi.get(self, "hci")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseOperationStatus(dict):
+    """
+    The detailed status of the long running operation.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "operationId":
+            suggest = "operation_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponseOperationStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponseOperationStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponseOperationStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error: Optional['outputs.VirtualNetworkPropertiesResponseError'] = None,
+                 operation_id: Optional[str] = None,
+                 status: Optional[str] = None):
+        """
+        The detailed status of the long running operation.
+        :param 'VirtualNetworkPropertiesResponseError' error: The error if any from the operation.
+        :param str operation_id: The identifier of the operation.
+        :param str status: The status of the operation.
+        """
+        if error is not None:
+            pulumi.set(__self__, "error", error)
+        if operation_id is not None:
+            pulumi.set(__self__, "operation_id", operation_id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def error(self) -> Optional['outputs.VirtualNetworkPropertiesResponseError']:
+        """
+        The error if any from the operation.
+        """
+        return pulumi.get(self, "error")
+
+    @property
+    @pulumi.getter(name="operationId")
+    def operation_id(self) -> Optional[str]:
+        """
+        The identifier of the operation.
+        """
+        return pulumi.get(self, "operation_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The status of the operation.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseStatus(dict):
+    """
+    Status of the virtual network resource
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "operationStatus":
+            suggest = "operation_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponseStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponseStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponseStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 operation_status: Optional['outputs.VirtualNetworkPropertiesResponseOperationStatus'] = None):
+        """
+        Status of the virtual network resource
+        :param 'VirtualNetworkPropertiesResponseOperationStatus' operation_status: The detailed status of the long running operation.
+        """
+        if operation_status is not None:
+            pulumi.set(__self__, "operation_status", operation_status)
+
+    @property
+    @pulumi.getter(name="operationStatus")
+    def operation_status(self) -> Optional['outputs.VirtualNetworkPropertiesResponseOperationStatus']:
+        """
+        The detailed status of the long running operation.
+        """
+        return pulumi.get(self, "operation_status")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseVipPool(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endIP":
+            suggest = "end_ip"
+        elif key == "startIP":
+            suggest = "start_ip"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponseVipPool. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponseVipPool.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponseVipPool.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 end_ip: Optional[str] = None,
+                 start_ip: Optional[str] = None):
+        """
+        :param str end_ip: Ending IP address for the IP Pool
+        :param str start_ip: Starting IP address for the IP Pool
+        """
+        if end_ip is not None:
+            pulumi.set(__self__, "end_ip", end_ip)
+        if start_ip is not None:
+            pulumi.set(__self__, "start_ip", start_ip)
+
+    @property
+    @pulumi.getter(name="endIP")
+    def end_ip(self) -> Optional[str]:
+        """
+        Ending IP address for the IP Pool
+        """
+        return pulumi.get(self, "end_ip")
+
+    @property
+    @pulumi.getter(name="startIP")
+    def start_ip(self) -> Optional[str]:
+        """
+        Starting IP address for the IP Pool
+        """
+        return pulumi.get(self, "start_ip")
+
+
+@pulumi.output_type
+class VirtualNetworkPropertiesResponseVmipPool(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endIP":
+            suggest = "end_ip"
+        elif key == "startIP":
+            suggest = "start_ip"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VirtualNetworkPropertiesResponseVmipPool. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VirtualNetworkPropertiesResponseVmipPool.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VirtualNetworkPropertiesResponseVmipPool.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 end_ip: Optional[str] = None,
+                 start_ip: Optional[str] = None):
+        """
+        :param str end_ip: Ending IP address for the IP Pool
+        :param str start_ip: Starting IP address for the IP Pool
+        """
+        if end_ip is not None:
+            pulumi.set(__self__, "end_ip", end_ip)
+        if start_ip is not None:
+            pulumi.set(__self__, "start_ip", start_ip)
+
+    @property
+    @pulumi.getter(name="endIP")
+    def end_ip(self) -> Optional[str]:
+        """
+        Ending IP address for the IP Pool
+        """
+        return pulumi.get(self, "end_ip")
+
+    @property
+    @pulumi.getter(name="startIP")
+    def start_ip(self) -> Optional[str]:
+        """
+        Starting IP address for the IP Pool
+        """
+        return pulumi.get(self, "start_ip")
+
+
+@pulumi.output_type
+class VirtualNetworkResponseExtendedLocation(dict):
+    """
+    Extended location pointing to the underlying infrastructure
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        Extended location pointing to the underlying infrastructure
+        :param str name: ARM Id of the extended location.
+        :param str type: The extended location type. Allowed value: 'CustomLocation'
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        ARM Id of the extended location.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The extended location type. Allowed value: 'CustomLocation'
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class VmSkuCapabilitiesResponse(dict):
+    """
+    Describes the VM SKU capabilities like MemoryGB, vCPUs, etc.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 value: str):
+        """
+        Describes the VM SKU capabilities like MemoryGB, vCPUs, etc.
+        :param str name: Name of the VM SKU capability
+        :param str value: Value of the VM SKU capability
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name of the VM SKU capability
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        Value of the VM SKU capability
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class VmSkuProfileResponseProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VmSkuProfileResponseProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VmSkuProfileResponseProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VmSkuProfileResponseProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: str,
+                 values: Optional[Sequence['outputs.VmSkuPropertiesResponse']] = None):
+        """
+        :param str provisioning_state: Provisioning state of the resource
+        :param Sequence['VmSkuPropertiesResponse'] values: List of supported VM SKUs.
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if values is not None:
+            pulumi.set(__self__, "values", values)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        Provisioning state of the resource
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def values(self) -> Optional[Sequence['outputs.VmSkuPropertiesResponse']]:
+        """
+        List of supported VM SKUs.
+        """
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class VmSkuPropertiesResponse(dict):
+    """
+    The profile for supported VM SKUs
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "resourceType":
+            suggest = "resource_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VmSkuPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VmSkuPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VmSkuPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 capabilities: Sequence['outputs.VmSkuCapabilitiesResponse'],
+                 name: str,
+                 resource_type: str,
+                 size: str,
+                 tier: str):
+        """
+        The profile for supported VM SKUs
+        :param Sequence['VmSkuCapabilitiesResponse'] capabilities: The list of name-value pairs to describe VM SKU capabilities like MemoryGB, vCPUs, etc.
+        :param str name: The name of the VM SKU
+        :param str resource_type: The type of resource the SKU applies to.
+        :param str size: The size of the VM SKU
+        :param str tier: The tier of the VM SKU
+        """
+        pulumi.set(__self__, "capabilities", capabilities)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "resource_type", resource_type)
+        pulumi.set(__self__, "size", size)
+        pulumi.set(__self__, "tier", tier)
+
+    @property
+    @pulumi.getter
+    def capabilities(self) -> Sequence['outputs.VmSkuCapabilitiesResponse']:
+        """
+        The list of name-value pairs to describe VM SKU capabilities like MemoryGB, vCPUs, etc.
+        """
+        return pulumi.get(self, "capabilities")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the VM SKU
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> str:
+        """
+        The type of resource the SKU applies to.
+        """
+        return pulumi.get(self, "resource_type")
+
+    @property
+    @pulumi.getter
+    def size(self) -> str:
+        """
+        The size of the VM SKU
+        """
+        return pulumi.get(self, "size")
+
+    @property
+    @pulumi.getter
+    def tier(self) -> str:
+        """
+        The tier of the VM SKU
+        """
+        return pulumi.get(self, "tier")
+
+