text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union
  from ... import _utilities, _tables
  from . import outputs
  from ._enums import *
  
  __all__ = [
      'AdditionalCapabilitiesResponse',
      'AdditionalUnattendContentResponse',
      'ApiEntityReferenceResponse',
      'ApiErrorBaseResponse',
      'ApiErrorResponse',
      'AutomaticOSUpgradePolicyResponse',
      'AutomaticRepairsPolicyResponse',
      'AvailablePatchSummaryResponse',
      'BillingProfileResponse',
      'BootDiagnosticsInstanceViewResponse',
      'BootDiagnosticsResponse',
      'CreationDataResponse',
      'DataDiskImageEncryptionResponse',
      'DataDiskResponse',
      'DedicatedHostAllocatableVMResponse',
      'DedicatedHostAvailableCapacityResponse',
      'DedicatedHostGroupInstanceViewResponse',
      'DedicatedHostInstanceViewResponse',
      'DedicatedHostInstanceViewWithNameResponse',
      'DiagnosticsProfileResponse',
      'DiffDiskSettingsResponse',
      'DisallowedResponse',
      'DiskEncryptionSetParametersResponse',
      'DiskEncryptionSettingsResponse',
      'DiskInstanceViewResponse',
      'DiskSkuResponse',
      'EncryptionImagesResponse',
      'EncryptionResponse',
      'EncryptionSetIdentityResponse',
      'EncryptionSettingsCollectionResponse',
      'EncryptionSettingsElementResponse',
      'ExtendedLocationResponse',
      'GalleryApplicationVersionPublishingProfileResponse',
      'GalleryArtifactVersionSourceResponse',
      'GalleryDataDiskImageResponse',
      'GalleryIdentifierResponse',
      'GalleryImageFeatureResponse',
      'GalleryImageIdentifierResponse',
      'GalleryImageVersionPublishingProfileResponse',
      'GalleryImageVersionStorageProfileResponse',
      'GalleryOSDiskImageResponse',
      'HardwareProfileResponse',
      'ImageDataDiskResponse',
      'ImageDiskReferenceResponse',
      'ImageOSDiskResponse',
      'ImagePurchasePlanResponse',
      'ImageReferenceResponse',
      'ImageStorageProfileResponse',
      'InnerErrorResponse',
      'InstanceViewStatusResponse',
      'KeyForDiskEncryptionSetResponse',
      'KeyVaultAndKeyReferenceResponse',
      'KeyVaultAndSecretReferenceResponse',
      'KeyVaultKeyReferenceResponse',
      'KeyVaultSecretReferenceResponse',
      'LastPatchInstallationSummaryResponse',
      'LinuxConfigurationResponse',
      'LinuxPatchSettingsResponse',
      'LogAnalyticsOutputResponseResult',
      'MaintenanceRedeployStatusResponse',
      'ManagedDiskParametersResponse',
      'NetworkInterfaceReferenceResponse',
      'NetworkProfileResponse',
      'OSDiskImageEncryptionResponse',
      'OSDiskResponse',
      'OSProfileResponse',
      'PatchSettingsResponse',
      'PlanResponse',
      'PrivateEndpointConnectionResponse',
      'PrivateEndpointResponse',
      'PrivateLinkServiceConnectionStateResponse',
      'PurchasePlanResponse',
      'RecommendedMachineConfigurationResponse',
      'RegionalReplicationStatusResponse',
      'ReplicationStatusResponse',
      'ResourceRangeResponse',
      'RollingUpgradePolicyResponse',
      'RunCommandInputParameterResponse',
      'ScaleInPolicyResponse',
      'ScheduledEventsProfileResponse',
      'SecurityProfileResponse',
      'ShareInfoElementResponse',
      'SharingProfileGroupResponse',
      'SharingProfileResponse',
      'SkuResponse',
      'SnapshotSkuResponse',
      'SourceVaultResponse',
      'SshConfigurationResponse',
      'SshPublicKeyResponse',
      'StorageProfileResponse',
      'SubResourceReadOnlyResponse',
      'SubResourceResponse',
      'SubResourceWithColocationStatusResponse',
      'TargetRegionResponse',
      'TerminateNotificationProfileResponse',
      'UefiSettingsResponse',
      'UpgradePolicyResponse',
      'UserArtifactManageResponse',
      'UserArtifactSourceResponse',
      'VaultCertificateResponse',
      'VaultSecretGroupResponse',
      'VirtualHardDiskResponse',
      'VirtualMachineAgentInstanceViewResponse',
      'VirtualMachineExtensionHandlerInstanceViewResponse',
      'VirtualMachineExtensionInstanceViewResponse',
      'VirtualMachineExtensionResponse',
      'VirtualMachineHealthStatusResponse',
      'VirtualMachineIdentityResponse',
      'VirtualMachineIdentityResponseUserAssignedIdentities',
      'VirtualMachineInstanceViewResponse',
      'VirtualMachinePatchStatusResponse',
      'VirtualMachineRunCommandInstanceViewResponse',
      'VirtualMachineRunCommandScriptSourceResponse',
      'VirtualMachineScaleSetDataDiskResponse',
      'VirtualMachineScaleSetExtensionProfileResponse',
      'VirtualMachineScaleSetExtensionResponse',
      'VirtualMachineScaleSetIPConfigurationResponse',
      'VirtualMachineScaleSetIdentityResponse',
      'VirtualMachineScaleSetIdentityResponseUserAssignedIdentities',
      'VirtualMachineScaleSetIpTagResponse',
      'VirtualMachineScaleSetManagedDiskParametersResponse',
      'VirtualMachineScaleSetNetworkConfigurationDnsSettingsResponse',
      'VirtualMachineScaleSetNetworkConfigurationResponse',
      'VirtualMachineScaleSetNetworkProfileResponse',
      'VirtualMachineScaleSetOSDiskResponse',
      'VirtualMachineScaleSetOSProfileResponse',
      'VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsResponse',
      'VirtualMachineScaleSetPublicIPAddressConfigurationResponse',
      'VirtualMachineScaleSetStorageProfileResponse',
      'VirtualMachineScaleSetVMInstanceViewResponse',
      'VirtualMachineScaleSetVMNetworkProfileConfigurationResponse',
      'VirtualMachineScaleSetVMProfileResponse',
      'VirtualMachineScaleSetVMProtectionPolicyResponse',
      'WinRMConfigurationResponse',
      'WinRMListenerResponse',
      'WindowsConfigurationResponse',
  ]
  
  @pulumi.output_type
  class AdditionalCapabilitiesResponse(dict):
      """
      Enables or disables a capability on the virtual machine or virtual machine scale set.
      """
      def __init__(__self__, *,
                   ultra_ssd_enabled: Optional[bool] = None):
          """
          Enables or disables a capability on the virtual machine or virtual machine scale set.
          :param bool ultra_ssd_enabled: The flag that enables or disables a capability to have one or more managed data disks with UltraSSD_LRS storage account type on the VM or VMSS. Managed disks with storage account type UltraSSD_LRS can be added to a virtual machine or virtual machine scale set only if this property is enabled.
          """
          if ultra_ssd_enabled is not None:
              pulumi.set(__self__, "ultra_ssd_enabled", ultra_ssd_enabled)
  
      @property
      @pulumi.getter(name="ultraSSDEnabled")
      def ultra_ssd_enabled(self) -> Optional[bool]:
          """
          The flag that enables or disables a capability to have one or more managed data disks with UltraSSD_LRS storage account type on the VM or VMSS. Managed disks with storage account type UltraSSD_LRS can be added to a virtual machine or virtual machine scale set only if this property is enabled.
          """
          return pulumi.get(self, "ultra_ssd_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class AdditionalUnattendContentResponse(dict):
      """
      Specifies additional XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup. Contents are defined by setting name, component name, and the pass in which the content is applied.
      """
      def __init__(__self__, *,
                   component_name: Optional[str] = None,
                   content: Optional[str] = None,
                   pass_name: Optional[str] = None,
                   setting_name: Optional[str] = None):
          """
          Specifies additional XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup. Contents are defined by setting name, component name, and the pass in which the content is applied.
          :param str component_name: The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
          :param str content: Specifies the XML formatted content that is added to the unattend.xml file for the specified path and component. The XML must be less than 4KB and must include the root element for the setting or feature that is being inserted.
          :param str pass_name: The pass name. Currently, the only allowable value is OobeSystem.
          :param str setting_name: Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
          """
          if component_name is not None:
              pulumi.set(__self__, "component_name", component_name)
          if content is not None:
              pulumi.set(__self__, "content", content)
          if pass_name is not None:
              pulumi.set(__self__, "pass_name", pass_name)
          if setting_name is not None:
              pulumi.set(__self__, "setting_name", setting_name)
  
      @property
      @pulumi.getter(name="componentName")
      def component_name(self) -> Optional[str]:
          """
          The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
          """
          return pulumi.get(self, "component_name")
  
      @property
      @pulumi.getter
      def content(self) -> Optional[str]:
          """
          Specifies the XML formatted content that is added to the unattend.xml file for the specified path and component. The XML must be less than 4KB and must include the root element for the setting or feature that is being inserted.
          """
          return pulumi.get(self, "content")
  
      @property
      @pulumi.getter(name="passName")
      def pass_name(self) -> Optional[str]:
          """
          The pass name. Currently, the only allowable value is OobeSystem.
          """
          return pulumi.get(self, "pass_name")
  
      @property
      @pulumi.getter(name="settingName")
      def setting_name(self) -> Optional[str]:
          """
          Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
          """
          return pulumi.get(self, "setting_name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApiEntityReferenceResponse(dict):
      """
      The API entity reference.
      """
      def __init__(__self__, *,
                   id: Optional[str] = None):
          """
          The API entity reference.
          :param str id: The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApiErrorBaseResponse(dict):
      """
      Api error base.
      """
      def __init__(__self__, *,
                   code: Optional[str] = None,
                   message: Optional[str] = None,
                   target: Optional[str] = None):
          """
          Api error base.
          :param str code: The error code.
          :param str message: The error message.
          :param str target: The target of the particular error.
          """
          if code is not None:
              pulumi.set(__self__, "code", code)
          if message is not None:
              pulumi.set(__self__, "message", message)
          if target is not None:
              pulumi.set(__self__, "target", target)
  
      @property
      @pulumi.getter
      def code(self) -> Optional[str]:
          """
          The error code.
          """
          return pulumi.get(self, "code")
  
      @property
      @pulumi.getter
      def message(self) -> Optional[str]:
          """
          The error message.
          """
          return pulumi.get(self, "message")
  
      @property
      @pulumi.getter
      def target(self) -> Optional[str]:
          """
          The target of the particular error.
          """
          return pulumi.get(self, "target")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApiErrorResponse(dict):
      """
      Api error.
      """
      def __init__(__self__, *,
                   code: Optional[str] = None,
                   details: Optional[Sequence['outputs.ApiErrorBaseResponse']] = None,
                   innererror: Optional['outputs.InnerErrorResponse'] = None,
                   message: Optional[str] = None,
                   target: Optional[str] = None):
          """
          Api error.
          :param str code: The error code.
          :param Sequence['ApiErrorBaseResponseArgs'] details: The Api error details
          :param 'InnerErrorResponseArgs' innererror: The Api inner error
          :param str message: The error message.
          :param str target: The target of the particular error.
          """
          if code is not None:
              pulumi.set(__self__, "code", code)
          if details is not None:
              pulumi.set(__self__, "details", details)
          if innererror is not None:
              pulumi.set(__self__, "innererror", innererror)
          if message is not None:
              pulumi.set(__self__, "message", message)
          if target is not None:
              pulumi.set(__self__, "target", target)
  
      @property
      @pulumi.getter
      def code(self) -> Optional[str]:
          """
          The error code.
          """
          return pulumi.get(self, "code")
  
      @property
      @pulumi.getter
      def details(self) -> Optional[Sequence['outputs.ApiErrorBaseResponse']]:
          """
          The Api error details
          """
          return pulumi.get(self, "details")
  
      @property
      @pulumi.getter
      def innererror(self) -> Optional['outputs.InnerErrorResponse']:
          """
          The Api inner error
          """
          return pulumi.get(self, "innererror")
  
      @property
      @pulumi.getter
      def message(self) -> Optional[str]:
          """
          The error message.
          """
          return pulumi.get(self, "message")
  
      @property
      @pulumi.getter
      def target(self) -> Optional[str]:
          """
          The target of the particular error.
          """
          return pulumi.get(self, "target")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class AutomaticOSUpgradePolicyResponse(dict):
      """
      The configuration parameters used for performing automatic OS upgrade.
      """
      def __init__(__self__, *,
                   disable_automatic_rollback: Optional[bool] = None,
                   enable_automatic_os_upgrade: Optional[bool] = None):
          """
          The configuration parameters used for performing automatic OS upgrade.
          :param bool disable_automatic_rollback: Whether OS image rollback feature should be disabled. Default value is false.
          :param bool enable_automatic_os_upgrade: Indicates whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer version of the OS image becomes available. Default value is false. <br><br> If this is set to true for Windows based scale sets, [enableAutomaticUpdates](https://docs.microsoft.com/dotnet/api/microsoft.azure.management.compute.models.windowsconfiguration.enableautomaticupdates?view=azure-dotnet) is automatically set to false and cannot be set to true.
          """
          if disable_automatic_rollback is not None:
              pulumi.set(__self__, "disable_automatic_rollback", disable_automatic_rollback)
          if enable_automatic_os_upgrade is not None:
              pulumi.set(__self__, "enable_automatic_os_upgrade", enable_automatic_os_upgrade)
  
      @property
      @pulumi.getter(name="disableAutomaticRollback")
      def disable_automatic_rollback(self) -> Optional[bool]:
          """
          Whether OS image rollback feature should be disabled. Default value is false.
          """
          return pulumi.get(self, "disable_automatic_rollback")
  
      @property
      @pulumi.getter(name="enableAutomaticOSUpgrade")
      def enable_automatic_os_upgrade(self) -> Optional[bool]:
          """
          Indicates whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer version of the OS image becomes available. Default value is false. <br><br> If this is set to true for Windows based scale sets, [enableAutomaticUpdates](https://docs.microsoft.com/dotnet/api/microsoft.azure.management.compute.models.windowsconfiguration.enableautomaticupdates?view=azure-dotnet) is automatically set to false and cannot be set to true.
          """
          return pulumi.get(self, "enable_automatic_os_upgrade")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class AutomaticRepairsPolicyResponse(dict):
      """
      Specifies the configuration parameters for automatic repairs on the virtual machine scale set.
      """
      def __init__(__self__, *,
                   enabled: Optional[bool] = None,
                   grace_period: Optional[str] = None):
          """
          Specifies the configuration parameters for automatic repairs on the virtual machine scale set.
          :param bool enabled: Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
          :param str grace_period: The amount of time for which automatic repairs are suspended due to a state change on VM. The grace time starts after the state change has completed. This helps avoid premature or accidental repairs. The time duration should be specified in ISO 8601 format. The minimum allowed grace period is 30 minutes (PT30M), which is also the default value. The maximum allowed grace period is 90 minutes (PT90M).
          """
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
          if grace_period is not None:
              pulumi.set(__self__, "grace_period", grace_period)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[bool]:
          """
          Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter(name="gracePeriod")
      def grace_period(self) -> Optional[str]:
          """
          The amount of time for which automatic repairs are suspended due to a state change on VM. The grace time starts after the state change has completed. This helps avoid premature or accidental repairs. The time duration should be specified in ISO 8601 format. The minimum allowed grace period is 30 minutes (PT30M), which is also the default value. The maximum allowed grace period is 90 minutes (PT90M).
          """
          return pulumi.get(self, "grace_period")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class AvailablePatchSummaryResponse(dict):
      """
      Describes the properties of an virtual machine instance view for available patch summary.
      """
      def __init__(__self__, *,
                   assessment_activity_id: str,
                   critical_and_security_patch_count: int,
                   error: 'outputs.ApiErrorResponse',
                   last_modified_time: str,
                   other_patch_count: int,
                   reboot_pending: bool,
                   start_time: str,
                   status: str):
          """
          Describes the properties of an virtual machine instance view for available patch summary.
          :param str assessment_activity_id: The activity ID of the operation that produced this result. It is used to correlate across CRP and extension logs.
          :param int critical_and_security_patch_count: The number of critical or security patches that have been detected as available and not yet installed.
          :param 'ApiErrorResponseArgs' error: The errors that were encountered during execution of the operation. The details array contains the list of them.
          :param str last_modified_time: The UTC timestamp when the operation began.
          :param int other_patch_count: The number of all available patches excluding critical and security.
          :param bool reboot_pending: The overall reboot status of the VM. It will be true when partially installed patches require a reboot to complete installation but the reboot has not yet occurred.
          :param str start_time: The UTC timestamp when the operation began.
          :param str status: The overall success or failure status of the operation. It remains "InProgress" until the operation completes. At that point it will become "Unknown", "Failed", "Succeeded", or "CompletedWithWarnings."
          """
          pulumi.set(__self__, "assessment_activity_id", assessment_activity_id)
          pulumi.set(__self__, "critical_and_security_patch_count", critical_and_security_patch_count)
          pulumi.set(__self__, "error", error)
          pulumi.set(__self__, "last_modified_time", last_modified_time)
          pulumi.set(__self__, "other_patch_count", other_patch_count)
          pulumi.set(__self__, "reboot_pending", reboot_pending)
          pulumi.set(__self__, "start_time", start_time)
          pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter(name="assessmentActivityId")
      def assessment_activity_id(self) -> str:
          """
          The activity ID of the operation that produced this result. It is used to correlate across CRP and extension logs.
          """
          return pulumi.get(self, "assessment_activity_id")
  
      @property
      @pulumi.getter(name="criticalAndSecurityPatchCount")
      def critical_and_security_patch_count(self) -> int:
          """
          The number of critical or security patches that have been detected as available and not yet installed.
          """
          return pulumi.get(self, "critical_and_security_patch_count")
  
      @property
      @pulumi.getter
      def error(self) -> 'outputs.ApiErrorResponse':
          """
          The errors that were encountered during execution of the operation. The details array contains the list of them.
          """
          return pulumi.get(self, "error")
  
      @property
      @pulumi.getter(name="lastModifiedTime")
      def last_modified_time(self) -> str:
          """
          The UTC timestamp when the operation began.
          """
          return pulumi.get(self, "last_modified_time")
  
      @property
      @pulumi.getter(name="otherPatchCount")
      def other_patch_count(self) -> int:
          """
          The number of all available patches excluding critical and security.
          """
          return pulumi.get(self, "other_patch_count")
  
      @property
      @pulumi.getter(name="rebootPending")
      def reboot_pending(self) -> bool:
          """
          The overall reboot status of the VM. It will be true when partially installed patches require a reboot to complete installation but the reboot has not yet occurred.
          """
          return pulumi.get(self, "reboot_pending")
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> str:
          """
          The UTC timestamp when the operation began.
          """
          return pulumi.get(self, "start_time")
  
      @property
      @pulumi.getter
      def status(self) -> str:
          """
          The overall success or failure status of the operation. It remains "InProgress" until the operation completes. At that point it will become "Unknown", "Failed", "Succeeded", or "CompletedWithWarnings."
          """
          return pulumi.get(self, "status")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class BillingProfileResponse(dict):
      """
      Specifies the billing related details of a Azure Spot VM or VMSS. <br><br>Minimum api-version: 2019-03-01.
      """
      def __init__(__self__, *,
                   max_price: Optional[float] = None):
          """
          Specifies the billing related details of a Azure Spot VM or VMSS. <br><br>Minimum api-version: 2019-03-01.
          :param float max_price: Specifies the maximum price you are willing to pay for a Azure Spot VM/VMSS. This price is in US Dollars. <br><br> This price will be compared with the current Azure Spot price for the VM size. Also, the prices are compared at the time of create/update of Azure Spot VM/VMSS and the operation will only succeed if  the maxPrice is greater than the current Azure Spot price. <br><br> The maxPrice will also be used for evicting a Azure Spot VM/VMSS if the current Azure Spot price goes beyond the maxPrice after creation of VM/VMSS. <br><br> Possible values are: <br><br> - Any decimal value greater than zero. Example: 0.01538 <br><br> -1 – indicates default price to be up-to on-demand. <br><br> You can set the maxPrice to -1 to indicate that the Azure Spot VM/VMSS should not be evicted for price reasons. Also, the default max price is -1 if it is not provided by you. <br><br>Minimum api-version: 2019-03-01.
          """
          if max_price is not None:
              pulumi.set(__self__, "max_price", max_price)
  
      @property
      @pulumi.getter(name="maxPrice")
      def max_price(self) -> Optional[float]:
          """
          Specifies the maximum price you are willing to pay for a Azure Spot VM/VMSS. This price is in US Dollars. <br><br> This price will be compared with the current Azure Spot price for the VM size. Also, the prices are compared at the time of create/update of Azure Spot VM/VMSS and the operation will only succeed if  the maxPrice is greater than the current Azure Spot price. <br><br> The maxPrice will also be used for evicting a Azure Spot VM/VMSS if the current Azure Spot price goes beyond the maxPrice after creation of VM/VMSS. <br><br> Possible values are: <br><br> - Any decimal value greater than zero. Example: 0.01538 <br><br> -1 – indicates default price to be up-to on-demand. <br><br> You can set the maxPrice to -1 to indicate that the Azure Spot VM/VMSS should not be evicted for price reasons. Also, the default max price is -1 if it is not provided by you. <br><br>Minimum api-version: 2019-03-01.
          """
          return pulumi.get(self, "max_price")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class BootDiagnosticsInstanceViewResponse(dict):
      """
      The instance view of a virtual machine boot diagnostics.
      """
      def __init__(__self__, *,
                   console_screenshot_blob_uri: str,
                   serial_console_log_blob_uri: str,
                   status: 'outputs.InstanceViewStatusResponse'):
          """
          The instance view of a virtual machine boot diagnostics.
          :param str console_screenshot_blob_uri: The console screenshot blob URI. <br><br>NOTE: This will **not** be set if boot diagnostics is currently enabled with managed storage.
          :param str serial_console_log_blob_uri: The serial console log blob Uri. <br><br>NOTE: This will **not** be set if boot diagnostics is currently enabled with managed storage.
          :param 'InstanceViewStatusResponseArgs' status: The boot diagnostics status information for the VM. <br><br> NOTE: It will be set only if there are errors encountered in enabling boot diagnostics.
          """
          pulumi.set(__self__, "console_screenshot_blob_uri", console_screenshot_blob_uri)
          pulumi.set(__self__, "serial_console_log_blob_uri", serial_console_log_blob_uri)
          pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter(name="consoleScreenshotBlobUri")
      def console_screenshot_blob_uri(self) -> str:
          """
          The console screenshot blob URI. <br><br>NOTE: This will **not** be set if boot diagnostics is currently enabled with managed storage.
          """
          return pulumi.get(self, "console_screenshot_blob_uri")
  
      @property
      @pulumi.getter(name="serialConsoleLogBlobUri")
      def serial_console_log_blob_uri(self) -> str:
          """
          The serial console log blob Uri. <br><br>NOTE: This will **not** be set if boot diagnostics is currently enabled with managed storage.
          """
          return pulumi.get(self, "serial_console_log_blob_uri")
  
      @property
      @pulumi.getter
      def status(self) -> 'outputs.InstanceViewStatusResponse':
          """
          The boot diagnostics status information for the VM. <br><br> NOTE: It will be set only if there are errors encountered in enabling boot diagnostics.
          """
          return pulumi.get(self, "status")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class BootDiagnosticsResponse(dict):
      """
      Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
      """
      def __init__(__self__, *,
                   enabled: Optional[bool] = None,
                   storage_uri: Optional[str] = None):
          """
          Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          :param bool enabled: Whether boot diagnostics should be enabled on the Virtual Machine.
          :param str storage_uri: Uri of the storage account to use for placing the console output and screenshot. <br><br>If storageUri is not specified while enabling boot diagnostics, managed storage will be used.
          """
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
          if storage_uri is not None:
              pulumi.set(__self__, "storage_uri", storage_uri)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[bool]:
          """
          Whether boot diagnostics should be enabled on the Virtual Machine.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter(name="storageUri")
      def storage_uri(self) -> Optional[str]:
          """
          Uri of the storage account to use for placing the console output and screenshot. <br><br>If storageUri is not specified while enabling boot diagnostics, managed storage will be used.
          """
          return pulumi.get(self, "storage_uri")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class CreationDataResponse(dict):
      """
      Data used when creating a disk.
      """
      def __init__(__self__, *,
                   create_option: str,
                   source_unique_id: str,
                   gallery_image_reference: Optional['outputs.ImageDiskReferenceResponse'] = None,
                   image_reference: Optional['outputs.ImageDiskReferenceResponse'] = None,
                   logical_sector_size: Optional[int] = None,
                   source_resource_id: Optional[str] = None,
                   source_uri: Optional[str] = None,
                   storage_account_id: Optional[str] = None,
                   upload_size_bytes: Optional[float] = None):
          """
          Data used when creating a disk.
          :param str create_option: This enumerates the possible sources of a disk's creation.
          :param str source_unique_id: If this field is set, this is the unique id identifying the source of this resource.
          :param 'ImageDiskReferenceResponseArgs' gallery_image_reference: Required if creating from a Gallery Image. The id of the ImageDiskReference will be the ARM id of the shared galley image version from which to create a disk.
          :param 'ImageDiskReferenceResponseArgs' image_reference: Disk source information.
          :param int logical_sector_size: Logical sector size in bytes for Ultra disks. Supported values are 512 ad 4096. 4096 is the default.
          :param str source_resource_id: If createOption is Copy, this is the ARM id of the source snapshot or disk.
          :param str source_uri: If createOption is Import, this is the URI of a blob to be imported into a managed disk.
          :param str storage_account_id: Required if createOption is Import. The Azure Resource Manager identifier of the storage account containing the blob to import as a disk.
          :param float upload_size_bytes: If createOption is Upload, this is the size of the contents of the upload including the VHD footer. This value should be between 20972032 (20 MiB + 512 bytes for the VHD footer) and 35183298347520 bytes (32 TiB + 512 bytes for the VHD footer).
          """
          pulumi.set(__self__, "create_option", create_option)
          pulumi.set(__self__, "source_unique_id", source_unique_id)
          if gallery_image_reference is not None:
              pulumi.set(__self__, "gallery_image_reference", gallery_image_reference)
          if image_reference is not None:
              pulumi.set(__self__, "image_reference", image_reference)
          if logical_sector_size is not None:
              pulumi.set(__self__, "logical_sector_size", logical_sector_size)
          if source_resource_id is not None:
              pulumi.set(__self__, "source_resource_id", source_resource_id)
          if source_uri is not None:
              pulumi.set(__self__, "source_uri", source_uri)
          if storage_account_id is not None:
              pulumi.set(__self__, "storage_account_id", storage_account_id)
          if upload_size_bytes is not None:
              pulumi.set(__self__, "upload_size_bytes", upload_size_bytes)
  
      @property
      @pulumi.getter(name="createOption")
      def create_option(self) -> str:
          """
          This enumerates the possible sources of a disk's creation.
          """
          return pulumi.get(self, "create_option")
  
      @property
      @pulumi.getter(name="sourceUniqueId")
      def source_unique_id(self) -> str:
          """
          If this field is set, this is the unique id identifying the source of this resource.
          """
          return pulumi.get(self, "source_unique_id")
  
      @property
      @pulumi.getter(name="galleryImageReference")
      def gallery_image_reference(self) -> Optional['outputs.ImageDiskReferenceResponse']:
          """
          Required if creating from a Gallery Image. The id of the ImageDiskReference will be the ARM id of the shared galley image version from which to create a disk.
          """
          return pulumi.get(self, "gallery_image_reference")
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional['outputs.ImageDiskReferenceResponse']:
          """
          Disk source information.
          """
          return pulumi.get(self, "image_reference")
  
      @property
      @pulumi.getter(name="logicalSectorSize")
      def logical_sector_size(self) -> Optional[int]:
          """
          Logical sector size in bytes for Ultra disks. Supported values are 512 ad 4096. 4096 is the default.
          """
          return pulumi.get(self, "logical_sector_size")
  
      @property
      @pulumi.getter(name="sourceResourceId")
      def source_resource_id(self) -> Optional[str]:
          """
          If createOption is Copy, this is the ARM id of the source snapshot or disk.
          """
          return pulumi.get(self, "source_resource_id")
  
      @property
      @pulumi.getter(name="sourceUri")
      def source_uri(self) -> Optional[str]:
          """
          If createOption is Import, this is the URI of a blob to be imported into a managed disk.
          """
          return pulumi.get(self, "source_uri")
  
      @property
      @pulumi.getter(name="storageAccountId")
      def storage_account_id(self) -> Optional[str]:
          """
          Required if createOption is Import. The Azure Resource Manager identifier of the storage account containing the blob to import as a disk.
          """
          return pulumi.get(self, "storage_account_id")
  
      @property
      @pulumi.getter(name="uploadSizeBytes")
      def upload_size_bytes(self) -> Optional[float]:
          """
          If createOption is Upload, this is the size of the contents of the upload including the VHD footer. This value should be between 20972032 (20 MiB + 512 bytes for the VHD footer) and 35183298347520 bytes (32 TiB + 512 bytes for the VHD footer).
          """
          return pulumi.get(self, "upload_size_bytes")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DataDiskImageEncryptionResponse(dict):
      """
      Contains encryption settings for a data disk image.
      """
      def __init__(__self__, *,
                   lun: int,
                   disk_encryption_set_id: Optional[str] = None):
          """
          Contains encryption settings for a data disk image.
          :param int lun: This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
          :param str disk_encryption_set_id: A relative URI containing the resource ID of the disk encryption set.
          """
          pulumi.set(__self__, "lun", lun)
          if disk_encryption_set_id is not None:
              pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
  
      @property
      @pulumi.getter
      def lun(self) -> int:
          """
          This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
          """
          return pulumi.get(self, "lun")
  
      @property
      @pulumi.getter(name="diskEncryptionSetId")
      def disk_encryption_set_id(self) -> Optional[str]:
          """
          A relative URI containing the resource ID of the disk encryption set.
          """
          return pulumi.get(self, "disk_encryption_set_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DataDiskResponse(dict):
      """
      Describes a data disk.
      """
      def __init__(__self__, *,
                   create_option: str,
                   disk_iops_read_write: float,
                   disk_m_bps_read_write: float,
                   lun: int,
                   caching: Optional[str] = None,
                   detach_option: Optional[str] = None,
                   disk_size_gb: Optional[int] = None,
                   image: Optional['outputs.VirtualHardDiskResponse'] = None,
                   managed_disk: Optional['outputs.ManagedDiskParametersResponse'] = None,
                   name: Optional[str] = None,
                   to_be_detached: Optional[bool] = None,
                   vhd: Optional['outputs.VirtualHardDiskResponse'] = None,
                   write_accelerator_enabled: Optional[bool] = None):
          """
          Describes a data disk.
          :param str create_option: Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          :param float disk_iops_read_write: Specifies the Read-Write IOPS for the managed disk when StorageAccountType is UltraSSD_LRS. Returned only for VirtualMachine ScaleSet VM disks. Can be updated only via updates to the VirtualMachine Scale Set.
          :param float disk_m_bps_read_write: Specifies the bandwidth in MB per second for the managed disk when StorageAccountType is UltraSSD_LRS. Returned only for VirtualMachine ScaleSet VM disks. Can be updated only via updates to the VirtualMachine Scale Set.
          :param int lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          :param str detach_option: Specifies the detach behavior to be used while detaching a disk or which is already in the process of detachment from the virtual machine. Supported values: **ForceDetach**. <br><br> detachOption: **ForceDetach** is applicable only for managed data disks. If a previous detachment attempt of the data disk did not complete due to an unexpected failure from the virtual machine and the disk is still not released then use force-detach as a last resort option to detach the disk forcibly from the VM. All writes might not have been flushed when using this detach behavior. <br><br> This feature is still in preview mode and is not supported for VirtualMachineScaleSet. To force-detach a data disk update toBeDetached to 'true' along with setting detachOption: 'ForceDetach'.
          :param int disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'VirtualHardDiskResponseArgs' image: The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
          :param 'ManagedDiskParametersResponseArgs' managed_disk: The managed disk parameters.
          :param str name: The disk name.
          :param bool to_be_detached: Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
          :param 'VirtualHardDiskResponseArgs' vhd: The virtual hard disk.
          :param bool write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          pulumi.set(__self__, "create_option", create_option)
          pulumi.set(__self__, "disk_iops_read_write", disk_iops_read_write)
          pulumi.set(__self__, "disk_m_bps_read_write", disk_m_bps_read_write)
          pulumi.set(__self__, "lun", lun)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if detach_option is not None:
              pulumi.set(__self__, "detach_option", detach_option)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if image is not None:
              pulumi.set(__self__, "image", image)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if to_be_detached is not None:
              pulumi.set(__self__, "to_be_detached", to_be_detached)
          if vhd is not None:
              pulumi.set(__self__, "vhd", vhd)
          if write_accelerator_enabled is not None:
              pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
  
      @property
      @pulumi.getter(name="createOption")
      def create_option(self) -> str:
          """
          Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          """
          return pulumi.get(self, "create_option")
  
      @property
      @pulumi.getter(name="diskIOPSReadWrite")
      def disk_iops_read_write(self) -> float:
          """
          Specifies the Read-Write IOPS for the managed disk when StorageAccountType is UltraSSD_LRS. Returned only for VirtualMachine ScaleSet VM disks. Can be updated only via updates to the VirtualMachine Scale Set.
          """
          return pulumi.get(self, "disk_iops_read_write")
  
      @property
      @pulumi.getter(name="diskMBpsReadWrite")
      def disk_m_bps_read_write(self) -> float:
          """
          Specifies the bandwidth in MB per second for the managed disk when StorageAccountType is UltraSSD_LRS. Returned only for VirtualMachine ScaleSet VM disks. Can be updated only via updates to the VirtualMachine Scale Set.
          """
          return pulumi.get(self, "disk_m_bps_read_write")
  
      @property
      @pulumi.getter
      def lun(self) -> int:
          """
          Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          """
          return pulumi.get(self, "lun")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="detachOption")
      def detach_option(self) -> Optional[str]:
          """
          Specifies the detach behavior to be used while detaching a disk or which is already in the process of detachment from the virtual machine. Supported values: **ForceDetach**. <br><br> detachOption: **ForceDetach** is applicable only for managed data disks. If a previous detachment attempt of the data disk did not complete due to an unexpected failure from the virtual machine and the disk is still not released then use force-detach as a last resort option to detach the disk forcibly from the VM. All writes might not have been flushed when using this detach behavior. <br><br> This feature is still in preview mode and is not supported for VirtualMachineScaleSet. To force-detach a data disk update toBeDetached to 'true' along with setting detachOption: 'ForceDetach'.
          """
          return pulumi.get(self, "detach_option")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter
      def image(self) -> Optional['outputs.VirtualHardDiskResponse']:
          """
          The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
          """
          return pulumi.get(self, "image")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.ManagedDiskParametersResponse']:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="toBeDetached")
      def to_be_detached(self) -> Optional[bool]:
          """
          Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
          """
          return pulumi.get(self, "to_be_detached")
  
      @property
      @pulumi.getter
      def vhd(self) -> Optional['outputs.VirtualHardDiskResponse']:
          """
          The virtual hard disk.
          """
          return pulumi.get(self, "vhd")
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[bool]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DedicatedHostAllocatableVMResponse(dict):
      """
      Represents the dedicated host unutilized capacity in terms of a specific VM size.
      """
      def __init__(__self__, *,
                   count: Optional[float] = None,
                   vm_size: Optional[str] = None):
          """
          Represents the dedicated host unutilized capacity in terms of a specific VM size.
          :param float count: Maximum number of VMs of size vmSize that can fit in the dedicated host's remaining capacity.
          :param str vm_size: VM size in terms of which the unutilized capacity is represented.
          """
          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
      def count(self) -> Optional[float]:
          """
          Maximum number of VMs of size vmSize that can fit in the dedicated host's remaining capacity.
          """
          return pulumi.get(self, "count")
  
      @property
      @pulumi.getter(name="vmSize")
      def vm_size(self) -> Optional[str]:
          """
          VM size in terms of which the unutilized capacity is represented.
          """
          return pulumi.get(self, "vm_size")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DedicatedHostAvailableCapacityResponse(dict):
      """
      Dedicated host unutilized capacity.
      """
      def __init__(__self__, *,
                   allocatable_vms: Optional[Sequence['outputs.DedicatedHostAllocatableVMResponse']] = None):
          """
          Dedicated host unutilized capacity.
          :param Sequence['DedicatedHostAllocatableVMResponseArgs'] allocatable_vms: The unutilized capacity of the dedicated host represented in terms of each VM size that is allowed to be deployed to the dedicated host.
          """
          if allocatable_vms is not None:
              pulumi.set(__self__, "allocatable_vms", allocatable_vms)
  
      @property
      @pulumi.getter(name="allocatableVMs")
      def allocatable_vms(self) -> Optional[Sequence['outputs.DedicatedHostAllocatableVMResponse']]:
          """
          The unutilized capacity of the dedicated host represented in terms of each VM size that is allowed to be deployed to the dedicated host.
          """
          return pulumi.get(self, "allocatable_vms")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DedicatedHostGroupInstanceViewResponse(dict):
      def __init__(__self__, *,
                   hosts: Optional[Sequence['outputs.DedicatedHostInstanceViewWithNameResponse']] = None):
          """
          :param Sequence['DedicatedHostInstanceViewWithNameResponseArgs'] hosts: List of instance view of the dedicated hosts under the dedicated host group.
          """
          if hosts is not None:
              pulumi.set(__self__, "hosts", hosts)
  
      @property
      @pulumi.getter
      def hosts(self) -> Optional[Sequence['outputs.DedicatedHostInstanceViewWithNameResponse']]:
          """
          List of instance view of the dedicated hosts under the dedicated host group.
          """
          return pulumi.get(self, "hosts")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DedicatedHostInstanceViewResponse(dict):
      """
      The instance view of a dedicated host.
      """
      def __init__(__self__, *,
                   asset_id: str,
                   available_capacity: Optional['outputs.DedicatedHostAvailableCapacityResponse'] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None):
          """
          The instance view of a dedicated host.
          :param str asset_id: Specifies the unique id of the dedicated physical machine on which the dedicated host resides.
          :param 'DedicatedHostAvailableCapacityResponseArgs' available_capacity: Unutilized capacity of the dedicated host.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          """
          pulumi.set(__self__, "asset_id", asset_id)
          if available_capacity is not None:
              pulumi.set(__self__, "available_capacity", available_capacity)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
  
      @property
      @pulumi.getter(name="assetId")
      def asset_id(self) -> str:
          """
          Specifies the unique id of the dedicated physical machine on which the dedicated host resides.
          """
          return pulumi.get(self, "asset_id")
  
      @property
      @pulumi.getter(name="availableCapacity")
      def available_capacity(self) -> Optional['outputs.DedicatedHostAvailableCapacityResponse']:
          """
          Unutilized capacity of the dedicated host.
          """
          return pulumi.get(self, "available_capacity")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DedicatedHostInstanceViewWithNameResponse(dict):
      """
      The instance view of a dedicated host that includes the name of the dedicated host. It is used for the response to the instance view of a dedicated host group.
      """
      def __init__(__self__, *,
                   asset_id: str,
                   name: str,
                   available_capacity: Optional['outputs.DedicatedHostAvailableCapacityResponse'] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None):
          """
          The instance view of a dedicated host that includes the name of the dedicated host. It is used for the response to the instance view of a dedicated host group.
          :param str asset_id: Specifies the unique id of the dedicated physical machine on which the dedicated host resides.
          :param str name: The name of the dedicated host.
          :param 'DedicatedHostAvailableCapacityResponseArgs' available_capacity: Unutilized capacity of the dedicated host.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          """
          pulumi.set(__self__, "asset_id", asset_id)
          pulumi.set(__self__, "name", name)
          if available_capacity is not None:
              pulumi.set(__self__, "available_capacity", available_capacity)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
  
      @property
      @pulumi.getter(name="assetId")
      def asset_id(self) -> str:
          """
          Specifies the unique id of the dedicated physical machine on which the dedicated host resides.
          """
          return pulumi.get(self, "asset_id")
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the dedicated host.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="availableCapacity")
      def available_capacity(self) -> Optional['outputs.DedicatedHostAvailableCapacityResponse']:
          """
          Unutilized capacity of the dedicated host.
          """
          return pulumi.get(self, "available_capacity")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiagnosticsProfileResponse(dict):
      """
      Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
      """
      def __init__(__self__, *,
                   boot_diagnostics: Optional['outputs.BootDiagnosticsResponse'] = None):
          """
          Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          :param 'BootDiagnosticsResponseArgs' boot_diagnostics: Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          """
          if boot_diagnostics is not None:
              pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
  
      @property
      @pulumi.getter(name="bootDiagnostics")
      def boot_diagnostics(self) -> Optional['outputs.BootDiagnosticsResponse']:
          """
          Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          """
          return pulumi.get(self, "boot_diagnostics")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiffDiskSettingsResponse(dict):
      """
      Describes the parameters of ephemeral disk settings that can be specified for operating system disk. <br><br> NOTE: The ephemeral disk settings can only be specified for managed disk.
      """
      def __init__(__self__, *,
                   option: Optional[str] = None,
                   placement: Optional[str] = None):
          """
          Describes the parameters of ephemeral disk settings that can be specified for operating system disk. <br><br> NOTE: The ephemeral disk settings can only be specified for managed disk.
          :param str option: Specifies the ephemeral disk settings for operating system disk.
          :param str placement: Specifies the ephemeral disk placement for operating system disk.<br><br> Possible values are: <br><br> **CacheDisk** <br><br> **ResourceDisk** <br><br> Default: **CacheDisk** if one is configured for the VM size otherwise **ResourceDisk** is used.<br><br> Refer to VM size documentation for Windows VM at https://docs.microsoft.com/en-us/azure/virtual-machines/windows/sizes and Linux VM at https://docs.microsoft.com/en-us/azure/virtual-machines/linux/sizes to check which VM sizes exposes a cache disk.
          """
          if option is not None:
              pulumi.set(__self__, "option", option)
          if placement is not None:
              pulumi.set(__self__, "placement", placement)
  
      @property
      @pulumi.getter
      def option(self) -> Optional[str]:
          """
          Specifies the ephemeral disk settings for operating system disk.
          """
          return pulumi.get(self, "option")
  
      @property
      @pulumi.getter
      def placement(self) -> Optional[str]:
          """
          Specifies the ephemeral disk placement for operating system disk.<br><br> Possible values are: <br><br> **CacheDisk** <br><br> **ResourceDisk** <br><br> Default: **CacheDisk** if one is configured for the VM size otherwise **ResourceDisk** is used.<br><br> Refer to VM size documentation for Windows VM at https://docs.microsoft.com/en-us/azure/virtual-machines/windows/sizes and Linux VM at https://docs.microsoft.com/en-us/azure/virtual-machines/linux/sizes to check which VM sizes exposes a cache disk.
          """
          return pulumi.get(self, "placement")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DisallowedResponse(dict):
      """
      Describes the disallowed disk types.
      """
      def __init__(__self__, *,
                   disk_types: Optional[Sequence[str]] = None):
          """
          Describes the disallowed disk types.
          :param Sequence[str] disk_types: A list of disk types.
          """
          if disk_types is not None:
              pulumi.set(__self__, "disk_types", disk_types)
  
      @property
      @pulumi.getter(name="diskTypes")
      def disk_types(self) -> Optional[Sequence[str]]:
          """
          A list of disk types.
          """
          return pulumi.get(self, "disk_types")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiskEncryptionSetParametersResponse(dict):
      """
      Describes the parameter of customer managed disk encryption set resource id that can be specified for disk. <br><br> NOTE: The disk encryption set resource id can only be specified for managed disk. Please refer https://aka.ms/mdssewithcmkoverview for more details.
      """
      def __init__(__self__, *,
                   id: Optional[str] = None):
          """
          Describes the parameter of customer managed disk encryption set resource id that can be specified for disk. <br><br> NOTE: The disk encryption set resource id can only be specified for managed disk. Please refer https://aka.ms/mdssewithcmkoverview for more details.
          :param str id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiskEncryptionSettingsResponse(dict):
      """
      Describes a Encryption Settings for a Disk
      """
      def __init__(__self__, *,
                   disk_encryption_key: Optional['outputs.KeyVaultSecretReferenceResponse'] = None,
                   enabled: Optional[bool] = None,
                   key_encryption_key: Optional['outputs.KeyVaultKeyReferenceResponse'] = None):
          """
          Describes a Encryption Settings for a Disk
          :param 'KeyVaultSecretReferenceResponseArgs' disk_encryption_key: Specifies the location of the disk encryption key, which is a Key Vault Secret.
          :param bool enabled: Specifies whether disk encryption should be enabled on the virtual machine.
          :param 'KeyVaultKeyReferenceResponseArgs' key_encryption_key: Specifies the location of the key encryption key in Key Vault.
          """
          if disk_encryption_key is not None:
              pulumi.set(__self__, "disk_encryption_key", disk_encryption_key)
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
          if key_encryption_key is not None:
              pulumi.set(__self__, "key_encryption_key", key_encryption_key)
  
      @property
      @pulumi.getter(name="diskEncryptionKey")
      def disk_encryption_key(self) -> Optional['outputs.KeyVaultSecretReferenceResponse']:
          """
          Specifies the location of the disk encryption key, which is a Key Vault Secret.
          """
          return pulumi.get(self, "disk_encryption_key")
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[bool]:
          """
          Specifies whether disk encryption should be enabled on the virtual machine.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter(name="keyEncryptionKey")
      def key_encryption_key(self) -> Optional['outputs.KeyVaultKeyReferenceResponse']:
          """
          Specifies the location of the key encryption key in Key Vault.
          """
          return pulumi.get(self, "key_encryption_key")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiskInstanceViewResponse(dict):
      """
      The instance view of the disk.
      """
      def __init__(__self__, *,
                   encryption_settings: Optional[Sequence['outputs.DiskEncryptionSettingsResponse']] = None,
                   name: Optional[str] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None):
          """
          The instance view of the disk.
          :param Sequence['DiskEncryptionSettingsResponseArgs'] encryption_settings: Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          :param str name: The disk name.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          """
          if encryption_settings is not None:
              pulumi.set(__self__, "encryption_settings", encryption_settings)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
  
      @property
      @pulumi.getter(name="encryptionSettings")
      def encryption_settings(self) -> Optional[Sequence['outputs.DiskEncryptionSettingsResponse']]:
          """
          Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          """
          return pulumi.get(self, "encryption_settings")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiskSkuResponse(dict):
      """
      The disks sku name. Can be Standard_LRS, Premium_LRS, StandardSSD_LRS, or UltraSSD_LRS.
      """
      def __init__(__self__, *,
                   tier: str,
                   name: Optional[str] = None):
          """
          The disks sku name. Can be Standard_LRS, Premium_LRS, StandardSSD_LRS, or UltraSSD_LRS.
          :param str tier: The sku tier.
          :param str name: The sku name.
          """
          pulumi.set(__self__, "tier", tier)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def tier(self) -> str:
          """
          The sku tier.
          """
          return pulumi.get(self, "tier")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EncryptionImagesResponse(dict):
      """
      Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
      """
      def __init__(__self__, *,
                   data_disk_images: Optional[Sequence['outputs.DataDiskImageEncryptionResponse']] = None,
                   os_disk_image: Optional['outputs.OSDiskImageEncryptionResponse'] = None):
          """
          Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
          :param Sequence['DataDiskImageEncryptionResponseArgs'] data_disk_images: A list of encryption specifications for data disk images.
          :param 'OSDiskImageEncryptionResponseArgs' os_disk_image: Contains encryption settings for an OS disk image.
          """
          if data_disk_images is not None:
              pulumi.set(__self__, "data_disk_images", data_disk_images)
          if os_disk_image is not None:
              pulumi.set(__self__, "os_disk_image", os_disk_image)
  
      @property
      @pulumi.getter(name="dataDiskImages")
      def data_disk_images(self) -> Optional[Sequence['outputs.DataDiskImageEncryptionResponse']]:
          """
          A list of encryption specifications for data disk images.
          """
          return pulumi.get(self, "data_disk_images")
  
      @property
      @pulumi.getter(name="osDiskImage")
      def os_disk_image(self) -> Optional['outputs.OSDiskImageEncryptionResponse']:
          """
          Contains encryption settings for an OS disk image.
          """
          return pulumi.get(self, "os_disk_image")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EncryptionResponse(dict):
      """
      Encryption at rest settings for disk or snapshot
      """
      def __init__(__self__, *,
                   disk_encryption_set_id: Optional[str] = None,
                   type: Optional[str] = None):
          """
          Encryption at rest settings for disk or snapshot
          :param str disk_encryption_set_id: ResourceId of the disk encryption set to use for enabling encryption at rest.
          :param str type: The type of key used to encrypt the data of the disk.
          """
          if disk_encryption_set_id is not None:
              pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="diskEncryptionSetId")
      def disk_encryption_set_id(self) -> Optional[str]:
          """
          ResourceId of the disk encryption set to use for enabling encryption at rest.
          """
          return pulumi.get(self, "disk_encryption_set_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of key used to encrypt the data of the disk.
          """
          return pulumi.get(self, "type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EncryptionSetIdentityResponse(dict):
      """
      The managed identity for the disk encryption set. It should be given permission on the key vault before it can be used to encrypt disks.
      """
      def __init__(__self__, *,
                   principal_id: str,
                   tenant_id: str,
                   type: Optional[str] = None):
          """
          The managed identity for the disk encryption set. It should be given permission on the key vault before it can be used to encrypt disks.
          :param str principal_id: The object id of the Managed Identity Resource. This will be sent to the RP from ARM via the x-ms-identity-principal-id header in the PUT request if the resource has a systemAssigned(implicit) identity
          :param str tenant_id: The tenant id of the Managed Identity Resource. This will be sent to the RP from ARM via the x-ms-client-tenant-id header in the PUT request if the resource has a systemAssigned(implicit) identity
          :param str type: The type of Managed Identity used by the DiskEncryptionSet. Only SystemAssigned is supported for new creations. Disk Encryption Sets can be updated with Identity type None during migration of subscription to a new Azure Active Directory tenant; it will cause the encrypted resources to lose access to the keys.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "tenant_id", tenant_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The object id of the Managed Identity Resource. This will be sent to the RP from ARM via the x-ms-identity-principal-id header in the PUT request if the resource has a systemAssigned(implicit) identity
          """
          return pulumi.get(self, "principal_id")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> str:
          """
          The tenant id of the Managed Identity Resource. This will be sent to the RP from ARM via the x-ms-client-tenant-id header in the PUT request if the resource has a systemAssigned(implicit) identity
          """
          return pulumi.get(self, "tenant_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of Managed Identity used by the DiskEncryptionSet. Only SystemAssigned is supported for new creations. Disk Encryption Sets can be updated with Identity type None during migration of subscription to a new Azure Active Directory tenant; it will cause the encrypted resources to lose access to the keys.
          """
          return pulumi.get(self, "type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EncryptionSettingsCollectionResponse(dict):
      """
      Encryption settings for disk or snapshot
      """
      def __init__(__self__, *,
                   enabled: bool,
                   encryption_settings: Optional[Sequence['outputs.EncryptionSettingsElementResponse']] = None,
                   encryption_settings_version: Optional[str] = None):
          """
          Encryption settings for disk or snapshot
          :param bool enabled: Set this flag to true and provide DiskEncryptionKey and optional KeyEncryptionKey to enable encryption. Set this flag to false and remove DiskEncryptionKey and KeyEncryptionKey to disable encryption. If EncryptionSettings is null in the request object, the existing settings remain unchanged.
          :param Sequence['EncryptionSettingsElementResponseArgs'] encryption_settings: A collection of encryption settings, one for each disk volume.
          :param str encryption_settings_version: Describes what type of encryption is used for the disks. Once this field is set, it cannot be overwritten. '1.0' corresponds to Azure Disk Encryption with AAD app.'1.1' corresponds to Azure Disk Encryption.
          """
          pulumi.set(__self__, "enabled", enabled)
          if encryption_settings is not None:
              pulumi.set(__self__, "encryption_settings", encryption_settings)
          if encryption_settings_version is not None:
              pulumi.set(__self__, "encryption_settings_version", encryption_settings_version)
  
      @property
      @pulumi.getter
      def enabled(self) -> bool:
          """
          Set this flag to true and provide DiskEncryptionKey and optional KeyEncryptionKey to enable encryption. Set this flag to false and remove DiskEncryptionKey and KeyEncryptionKey to disable encryption. If EncryptionSettings is null in the request object, the existing settings remain unchanged.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter(name="encryptionSettings")
      def encryption_settings(self) -> Optional[Sequence['outputs.EncryptionSettingsElementResponse']]:
          """
          A collection of encryption settings, one for each disk volume.
          """
          return pulumi.get(self, "encryption_settings")
  
      @property
      @pulumi.getter(name="encryptionSettingsVersion")
      def encryption_settings_version(self) -> Optional[str]:
          """
          Describes what type of encryption is used for the disks. Once this field is set, it cannot be overwritten. '1.0' corresponds to Azure Disk Encryption with AAD app.'1.1' corresponds to Azure Disk Encryption.
          """
          return pulumi.get(self, "encryption_settings_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EncryptionSettingsElementResponse(dict):
      """
      Encryption settings for one disk volume.
      """
      def __init__(__self__, *,
                   disk_encryption_key: Optional['outputs.KeyVaultAndSecretReferenceResponse'] = None,
                   key_encryption_key: Optional['outputs.KeyVaultAndKeyReferenceResponse'] = None):
          """
          Encryption settings for one disk volume.
          :param 'KeyVaultAndSecretReferenceResponseArgs' disk_encryption_key: Key Vault Secret Url and vault id of the disk encryption key
          :param 'KeyVaultAndKeyReferenceResponseArgs' key_encryption_key: Key Vault Key Url and vault id of the key encryption key. KeyEncryptionKey is optional and when provided is used to unwrap the disk encryption key.
          """
          if disk_encryption_key is not None:
              pulumi.set(__self__, "disk_encryption_key", disk_encryption_key)
          if key_encryption_key is not None:
              pulumi.set(__self__, "key_encryption_key", key_encryption_key)
  
      @property
      @pulumi.getter(name="diskEncryptionKey")
      def disk_encryption_key(self) -> Optional['outputs.KeyVaultAndSecretReferenceResponse']:
          """
          Key Vault Secret Url and vault id of the disk encryption key
          """
          return pulumi.get(self, "disk_encryption_key")
  
      @property
      @pulumi.getter(name="keyEncryptionKey")
      def key_encryption_key(self) -> Optional['outputs.KeyVaultAndKeyReferenceResponse']:
          """
          Key Vault Key Url and vault id of the key encryption key. KeyEncryptionKey is optional and when provided is used to unwrap the disk encryption key.
          """
          return pulumi.get(self, "key_encryption_key")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ExtendedLocationResponse(dict):
      """
      The complex type of the extended location.
      """
      def __init__(__self__, *,
                   name: Optional[str] = None,
                   type: Optional[str] = None):
          """
          The complex type of the extended location.
          :param str name: The name of the extended location.
          :param str type: The type of the extended location.
          """
          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]:
          """
          The name of the extended location.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of the extended location.
          """
          return pulumi.get(self, "type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryApplicationVersionPublishingProfileResponse(dict):
      """
      The publishing profile of a gallery image version.
      """
      def __init__(__self__, *,
                   published_date: str,
                   source: 'outputs.UserArtifactSourceResponse',
                   enable_health_check: Optional[bool] = None,
                   end_of_life_date: Optional[str] = None,
                   exclude_from_latest: Optional[bool] = None,
                   manage_actions: Optional['outputs.UserArtifactManageResponse'] = None,
                   replica_count: Optional[int] = None,
                   storage_account_type: Optional[str] = None,
                   target_regions: Optional[Sequence['outputs.TargetRegionResponse']] = None):
          """
          The publishing profile of a gallery image version.
          :param str published_date: The timestamp for when the gallery image version is published.
          :param 'UserArtifactSourceResponseArgs' source: The source image from which the Image Version is going to be created.
          :param bool enable_health_check: Optional. Whether or not this application reports health.
          :param str end_of_life_date: The end of life date of the gallery image version. This property can be used for decommissioning purposes. This property is updatable.
          :param bool exclude_from_latest: If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
          :param int replica_count: The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
          :param str storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
          :param Sequence['TargetRegionResponseArgs'] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          pulumi.set(__self__, "published_date", published_date)
          pulumi.set(__self__, "source", source)
          if enable_health_check is not None:
              pulumi.set(__self__, "enable_health_check", enable_health_check)
          if end_of_life_date is not None:
              pulumi.set(__self__, "end_of_life_date", end_of_life_date)
          if exclude_from_latest is not None:
              pulumi.set(__self__, "exclude_from_latest", exclude_from_latest)
          if manage_actions is not None:
              pulumi.set(__self__, "manage_actions", manage_actions)
          if replica_count is not None:
              pulumi.set(__self__, "replica_count", replica_count)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
          if target_regions is not None:
              pulumi.set(__self__, "target_regions", target_regions)
  
      @property
      @pulumi.getter(name="publishedDate")
      def published_date(self) -> str:
          """
          The timestamp for when the gallery image version is published.
          """
          return pulumi.get(self, "published_date")
  
      @property
      @pulumi.getter
      def source(self) -> 'outputs.UserArtifactSourceResponse':
          """
          The source image from which the Image Version is going to be created.
          """
          return pulumi.get(self, "source")
  
      @property
      @pulumi.getter(name="enableHealthCheck")
      def enable_health_check(self) -> Optional[bool]:
          """
          Optional. Whether or not this application reports health.
          """
          return pulumi.get(self, "enable_health_check")
  
      @property
      @pulumi.getter(name="endOfLifeDate")
      def end_of_life_date(self) -> Optional[str]:
          """
          The end of life date of the gallery image version. This property can be used for decommissioning purposes. This property is updatable.
          """
          return pulumi.get(self, "end_of_life_date")
  
      @property
      @pulumi.getter(name="excludeFromLatest")
      def exclude_from_latest(self) -> Optional[bool]:
          """
          If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
          """
          return pulumi.get(self, "exclude_from_latest")
  
      @property
      @pulumi.getter(name="manageActions")
      def manage_actions(self) -> Optional['outputs.UserArtifactManageResponse']:
          return pulumi.get(self, "manage_actions")
  
      @property
      @pulumi.getter(name="replicaCount")
      def replica_count(self) -> Optional[int]:
          """
          The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
          """
          return pulumi.get(self, "replica_count")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      @property
      @pulumi.getter(name="targetRegions")
      def target_regions(self) -> Optional[Sequence['outputs.TargetRegionResponse']]:
          """
          The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          return pulumi.get(self, "target_regions")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryArtifactVersionSourceResponse(dict):
      """
      The gallery artifact version source.
      """
      def __init__(__self__, *,
                   id: Optional[str] = None,
                   uri: Optional[str] = None):
          """
          The gallery artifact version source.
          :param str id: The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, user image or storage account resource.
          :param str uri: The uri of the gallery artifact version source. Currently used to specify vhd/blob source.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if uri is not None:
              pulumi.set(__self__, "uri", uri)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, user image or storage account resource.
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def uri(self) -> Optional[str]:
          """
          The uri of the gallery artifact version source. Currently used to specify vhd/blob source.
          """
          return pulumi.get(self, "uri")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryDataDiskImageResponse(dict):
      """
      This is the data disk image.
      """
      def __init__(__self__, *,
                   lun: int,
                   size_in_gb: int,
                   host_caching: Optional[str] = None,
                   source: Optional['outputs.GalleryArtifactVersionSourceResponse'] = None):
          """
          This is the data disk image.
          :param int lun: This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
          :param int size_in_gb: This property indicates the size of the VHD to be created.
          :param str host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          :param 'GalleryArtifactVersionSourceResponseArgs' source: The gallery artifact version source.
          """
          pulumi.set(__self__, "lun", lun)
          pulumi.set(__self__, "size_in_gb", size_in_gb)
          if host_caching is not None:
              pulumi.set(__self__, "host_caching", host_caching)
          if source is not None:
              pulumi.set(__self__, "source", source)
  
      @property
      @pulumi.getter
      def lun(self) -> int:
          """
          This property specifies the logical unit number of the data disk. This value is used to identify data disks within the Virtual Machine and therefore must be unique for each data disk attached to the Virtual Machine.
          """
          return pulumi.get(self, "lun")
  
      @property
      @pulumi.getter(name="sizeInGB")
      def size_in_gb(self) -> int:
          """
          This property indicates the size of the VHD to be created.
          """
          return pulumi.get(self, "size_in_gb")
  
      @property
      @pulumi.getter(name="hostCaching")
      def host_caching(self) -> Optional[str]:
          """
          The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          """
          return pulumi.get(self, "host_caching")
  
      @property
      @pulumi.getter
      def source(self) -> Optional['outputs.GalleryArtifactVersionSourceResponse']:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryIdentifierResponse(dict):
      """
      Describes the gallery unique name.
      """
      def __init__(__self__, *,
                   unique_name: str):
          """
          Describes the gallery unique name.
          :param str unique_name: The unique name of the Shared Image Gallery. This name is generated automatically by Azure.
          """
          pulumi.set(__self__, "unique_name", unique_name)
  
      @property
      @pulumi.getter(name="uniqueName")
      def unique_name(self) -> str:
          """
          The unique name of the Shared Image Gallery. This name is generated automatically by Azure.
          """
          return pulumi.get(self, "unique_name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryImageFeatureResponse(dict):
      """
      A feature for gallery image.
      """
      def __init__(__self__, *,
                   name: Optional[str] = None,
                   value: Optional[str] = None):
          """
          A feature for gallery image.
          :param str name: The name of the gallery image feature.
          :param str value: The value of the gallery image feature.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
          if value is not None:
              pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The name of the gallery image feature.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def value(self) -> Optional[str]:
          """
          The value of the gallery image feature.
          """
          return pulumi.get(self, "value")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryImageIdentifierResponse(dict):
      """
      This is the gallery image definition identifier.
      """
      def __init__(__self__, *,
                   offer: str,
                   publisher: str,
                   sku: str):
          """
          This is the gallery image definition identifier.
          :param str offer: The name of the gallery image definition offer.
          :param str publisher: The name of the gallery image definition publisher.
          :param str sku: The name of the gallery image definition SKU.
          """
          pulumi.set(__self__, "offer", offer)
          pulumi.set(__self__, "publisher", publisher)
          pulumi.set(__self__, "sku", sku)
  
      @property
      @pulumi.getter
      def offer(self) -> str:
          """
          The name of the gallery image definition offer.
          """
          return pulumi.get(self, "offer")
  
      @property
      @pulumi.getter
      def publisher(self) -> str:
          """
          The name of the gallery image definition publisher.
          """
          return pulumi.get(self, "publisher")
  
      @property
      @pulumi.getter
      def sku(self) -> str:
          """
          The name of the gallery image definition SKU.
          """
          return pulumi.get(self, "sku")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryImageVersionPublishingProfileResponse(dict):
      """
      The publishing profile of a gallery image Version.
      """
      def __init__(__self__, *,
                   published_date: str,
                   end_of_life_date: Optional[str] = None,
                   exclude_from_latest: Optional[bool] = None,
                   replica_count: Optional[int] = None,
                   storage_account_type: Optional[str] = None,
                   target_regions: Optional[Sequence['outputs.TargetRegionResponse']] = None):
          """
          The publishing profile of a gallery image Version.
          :param str published_date: The timestamp for when the gallery image version is published.
          :param str end_of_life_date: The end of life date of the gallery image version. This property can be used for decommissioning purposes. This property is updatable.
          :param bool exclude_from_latest: If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
          :param int replica_count: The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
          :param str storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
          :param Sequence['TargetRegionResponseArgs'] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          pulumi.set(__self__, "published_date", published_date)
          if end_of_life_date is not None:
              pulumi.set(__self__, "end_of_life_date", end_of_life_date)
          if exclude_from_latest is not None:
              pulumi.set(__self__, "exclude_from_latest", exclude_from_latest)
          if replica_count is not None:
              pulumi.set(__self__, "replica_count", replica_count)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
          if target_regions is not None:
              pulumi.set(__self__, "target_regions", target_regions)
  
      @property
      @pulumi.getter(name="publishedDate")
      def published_date(self) -> str:
          """
          The timestamp for when the gallery image version is published.
          """
          return pulumi.get(self, "published_date")
  
      @property
      @pulumi.getter(name="endOfLifeDate")
      def end_of_life_date(self) -> Optional[str]:
          """
          The end of life date of the gallery image version. This property can be used for decommissioning purposes. This property is updatable.
          """
          return pulumi.get(self, "end_of_life_date")
  
      @property
      @pulumi.getter(name="excludeFromLatest")
      def exclude_from_latest(self) -> Optional[bool]:
          """
          If set to true, Virtual Machines deployed from the latest version of the Image Definition won't use this Image Version.
          """
          return pulumi.get(self, "exclude_from_latest")
  
      @property
      @pulumi.getter(name="replicaCount")
      def replica_count(self) -> Optional[int]:
          """
          The number of replicas of the Image Version to be created per region. This property would take effect for a region when regionalReplicaCount is not specified. This property is updatable.
          """
          return pulumi.get(self, "replica_count")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      @property
      @pulumi.getter(name="targetRegions")
      def target_regions(self) -> Optional[Sequence['outputs.TargetRegionResponse']]:
          """
          The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          return pulumi.get(self, "target_regions")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryImageVersionStorageProfileResponse(dict):
      """
      This is the storage profile of a Gallery Image Version.
      """
      def __init__(__self__, *,
                   data_disk_images: Optional[Sequence['outputs.GalleryDataDiskImageResponse']] = None,
                   os_disk_image: Optional['outputs.GalleryOSDiskImageResponse'] = None,
                   source: Optional['outputs.GalleryArtifactVersionSourceResponse'] = None):
          """
          This is the storage profile of a Gallery Image Version.
          :param Sequence['GalleryDataDiskImageResponseArgs'] data_disk_images: A list of data disk images.
          :param 'GalleryOSDiskImageResponseArgs' os_disk_image: This is the OS disk image.
          :param 'GalleryArtifactVersionSourceResponseArgs' source: The gallery artifact version source.
          """
          if data_disk_images is not None:
              pulumi.set(__self__, "data_disk_images", data_disk_images)
          if os_disk_image is not None:
              pulumi.set(__self__, "os_disk_image", os_disk_image)
          if source is not None:
              pulumi.set(__self__, "source", source)
  
      @property
      @pulumi.getter(name="dataDiskImages")
      def data_disk_images(self) -> Optional[Sequence['outputs.GalleryDataDiskImageResponse']]:
          """
          A list of data disk images.
          """
          return pulumi.get(self, "data_disk_images")
  
      @property
      @pulumi.getter(name="osDiskImage")
      def os_disk_image(self) -> Optional['outputs.GalleryOSDiskImageResponse']:
          """
          This is the OS disk image.
          """
          return pulumi.get(self, "os_disk_image")
  
      @property
      @pulumi.getter
      def source(self) -> Optional['outputs.GalleryArtifactVersionSourceResponse']:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class GalleryOSDiskImageResponse(dict):
      """
      This is the OS disk image.
      """
      def __init__(__self__, *,
                   size_in_gb: int,
                   host_caching: Optional[str] = None,
                   source: Optional['outputs.GalleryArtifactVersionSourceResponse'] = None):
          """
          This is the OS disk image.
          :param int size_in_gb: This property indicates the size of the VHD to be created.
          :param str host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          :param 'GalleryArtifactVersionSourceResponseArgs' source: The gallery artifact version source.
          """
          pulumi.set(__self__, "size_in_gb", size_in_gb)
          if host_caching is not None:
              pulumi.set(__self__, "host_caching", host_caching)
          if source is not None:
              pulumi.set(__self__, "source", source)
  
      @property
      @pulumi.getter(name="sizeInGB")
      def size_in_gb(self) -> int:
          """
          This property indicates the size of the VHD to be created.
          """
          return pulumi.get(self, "size_in_gb")
  
      @property
      @pulumi.getter(name="hostCaching")
      def host_caching(self) -> Optional[str]:
          """
          The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          """
          return pulumi.get(self, "host_caching")
  
      @property
      @pulumi.getter
      def source(self) -> Optional['outputs.GalleryArtifactVersionSourceResponse']:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class HardwareProfileResponse(dict):
      """
      Specifies the hardware settings for the virtual machine.
      """
      def __init__(__self__, *,
                   vm_size: Optional[str] = None):
          """
          Specifies the hardware settings for the virtual machine.
          :param str vm_size: Specifies the size of the virtual machine. <br><br> The enum data type is currently deprecated and will be removed by December 23rd 2023. <br><br> Recommended way to get the list of available sizes is using these APIs: <br><br> [List all available virtual machine sizes in an availability set](https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes) <br><br> [List all available virtual machine sizes in a region]( https://docs.microsoft.com/en-us/rest/api/compute/resourceskus/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes). For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/en-us/azure/virtual-machines/sizes). <br><br> The available VM sizes depend on region and availability set.
          """
          if vm_size is not None:
              pulumi.set(__self__, "vm_size", vm_size)
  
      @property
      @pulumi.getter(name="vmSize")
      def vm_size(self) -> Optional[str]:
          """
          Specifies the size of the virtual machine. <br><br> The enum data type is currently deprecated and will be removed by December 23rd 2023. <br><br> Recommended way to get the list of available sizes is using these APIs: <br><br> [List all available virtual machine sizes in an availability set](https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes) <br><br> [List all available virtual machine sizes in a region]( https://docs.microsoft.com/en-us/rest/api/compute/resourceskus/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes). For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/en-us/azure/virtual-machines/sizes). <br><br> The available VM sizes depend on region and availability set.
          """
          return pulumi.get(self, "vm_size")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImageDataDiskResponse(dict):
      """
      Describes a data disk.
      """
      def __init__(__self__, *,
                   lun: int,
                   blob_uri: Optional[str] = None,
                   caching: Optional[str] = None,
                   disk_encryption_set: Optional['outputs.DiskEncryptionSetParametersResponse'] = None,
                   disk_size_gb: Optional[int] = None,
                   managed_disk: Optional['outputs.SubResourceResponse'] = None,
                   snapshot: Optional['outputs.SubResourceResponse'] = None,
                   storage_account_type: Optional[str] = None):
          """
          Describes a data disk.
          :param int lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          :param str blob_uri: The Virtual Hard Disk.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          :param 'DiskEncryptionSetParametersResponseArgs' disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
          :param int disk_size_gb: Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'SubResourceResponseArgs' managed_disk: The managedDisk.
          :param 'SubResourceResponseArgs' snapshot: The snapshot.
          :param str storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          pulumi.set(__self__, "lun", lun)
          if blob_uri is not None:
              pulumi.set(__self__, "blob_uri", blob_uri)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if disk_encryption_set is not None:
              pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if snapshot is not None:
              pulumi.set(__self__, "snapshot", snapshot)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
  
      @property
      @pulumi.getter
      def lun(self) -> int:
          """
          Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          """
          return pulumi.get(self, "lun")
  
      @property
      @pulumi.getter(name="blobUri")
      def blob_uri(self) -> Optional[str]:
          """
          The Virtual Hard Disk.
          """
          return pulumi.get(self, "blob_uri")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional['outputs.DiskEncryptionSetParametersResponse']:
          """
          Specifies the customer managed disk encryption set resource id for the managed image disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.SubResourceResponse']:
          """
          The managedDisk.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def snapshot(self) -> Optional['outputs.SubResourceResponse']:
          """
          The snapshot.
          """
          return pulumi.get(self, "snapshot")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          return pulumi.get(self, "storage_account_type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImageDiskReferenceResponse(dict):
      """
      The source image used for creating the disk.
      """
      def __init__(__self__, *,
                   id: str,
                   lun: Optional[int] = None):
          """
          The source image used for creating the disk.
          :param str id: A relative uri containing either a Platform Image Repository or user image reference.
          :param int lun: If the disk is created from an image's data disk, this is an index that indicates which of the data disks in the image to use. For OS disks, this field is null.
          """
          pulumi.set(__self__, "id", id)
          if lun is not None:
              pulumi.set(__self__, "lun", lun)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          A relative uri containing either a Platform Image Repository or user image reference.
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def lun(self) -> Optional[int]:
          """
          If the disk is created from an image's data disk, this is an index that indicates which of the data disks in the image to use. For OS disks, this field is null.
          """
          return pulumi.get(self, "lun")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImageOSDiskResponse(dict):
      """
      Describes an Operating System disk.
      """
      def __init__(__self__, *,
                   os_state: str,
                   os_type: str,
                   blob_uri: Optional[str] = None,
                   caching: Optional[str] = None,
                   disk_encryption_set: Optional['outputs.DiskEncryptionSetParametersResponse'] = None,
                   disk_size_gb: Optional[int] = None,
                   managed_disk: Optional['outputs.SubResourceResponse'] = None,
                   snapshot: Optional['outputs.SubResourceResponse'] = None,
                   storage_account_type: Optional[str] = None):
          """
          Describes an Operating System disk.
          :param str os_state: The OS State.
          :param str os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          :param str blob_uri: The Virtual Hard Disk.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          :param 'DiskEncryptionSetParametersResponseArgs' disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
          :param int disk_size_gb: Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'SubResourceResponseArgs' managed_disk: The managedDisk.
          :param 'SubResourceResponseArgs' snapshot: The snapshot.
          :param str storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          pulumi.set(__self__, "os_state", os_state)
          pulumi.set(__self__, "os_type", os_type)
          if blob_uri is not None:
              pulumi.set(__self__, "blob_uri", blob_uri)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if disk_encryption_set is not None:
              pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if snapshot is not None:
              pulumi.set(__self__, "snapshot", snapshot)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
  
      @property
      @pulumi.getter(name="osState")
      def os_state(self) -> str:
          """
          The OS State.
          """
          return pulumi.get(self, "os_state")
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> str:
          """
          This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          """
          return pulumi.get(self, "os_type")
  
      @property
      @pulumi.getter(name="blobUri")
      def blob_uri(self) -> Optional[str]:
          """
          The Virtual Hard Disk.
          """
          return pulumi.get(self, "blob_uri")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional['outputs.DiskEncryptionSetParametersResponse']:
          """
          Specifies the customer managed disk encryption set resource id for the managed image disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.SubResourceResponse']:
          """
          The managedDisk.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def snapshot(self) -> Optional['outputs.SubResourceResponse']:
          """
          The snapshot.
          """
          return pulumi.get(self, "snapshot")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          return pulumi.get(self, "storage_account_type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImagePurchasePlanResponse(dict):
      """
      Describes the gallery image definition purchase plan. This is used by marketplace images.
      """
      def __init__(__self__, *,
                   name: Optional[str] = None,
                   product: Optional[str] = None,
                   publisher: Optional[str] = None):
          """
          Describes the gallery image definition purchase plan. This is used by marketplace images.
          :param str name: The plan ID.
          :param str product: The product ID.
          :param str publisher: The publisher ID.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
          if product is not None:
              pulumi.set(__self__, "product", product)
          if publisher is not None:
              pulumi.set(__self__, "publisher", publisher)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The plan ID.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def product(self) -> Optional[str]:
          """
          The product ID.
          """
          return pulumi.get(self, "product")
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[str]:
          """
          The publisher ID.
          """
          return pulumi.get(self, "publisher")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImageReferenceResponse(dict):
      """
      Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations. NOTE: Image reference publisher and offer can only be set when you create the scale set.
      """
      def __init__(__self__, *,
                   exact_version: str,
                   id: Optional[str] = None,
                   offer: Optional[str] = None,
                   publisher: Optional[str] = None,
                   sku: Optional[str] = None,
                   version: Optional[str] = None):
          """
          Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations. NOTE: Image reference publisher and offer can only be set when you create the scale set.
          :param str exact_version: Specifies in decimal numbers, the version of platform image or marketplace image used to create the virtual machine. This readonly field differs from 'version', only if the value specified in 'version' field is 'latest'.
          :param str id: Resource Id
          :param str offer: Specifies the offer of the platform image or marketplace image used to create the virtual machine.
          :param str publisher: The image publisher.
          :param str sku: The image SKU.
          :param str version: Specifies the version of the platform image or marketplace image used to create the virtual machine. The allowed formats are Major.Minor.Build or 'latest'. Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest version of an image available at deploy time. Even if you use 'latest', the VM image will not automatically update after deploy time even if a new version becomes available.
          """
          pulumi.set(__self__, "exact_version", exact_version)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if offer is not None:
              pulumi.set(__self__, "offer", offer)
          if publisher is not None:
              pulumi.set(__self__, "publisher", publisher)
          if sku is not None:
              pulumi.set(__self__, "sku", sku)
          if version is not None:
              pulumi.set(__self__, "version", version)
  
      @property
      @pulumi.getter(name="exactVersion")
      def exact_version(self) -> str:
          """
          Specifies in decimal numbers, the version of platform image or marketplace image used to create the virtual machine. This readonly field differs from 'version', only if the value specified in 'version' field is 'latest'.
          """
          return pulumi.get(self, "exact_version")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def offer(self) -> Optional[str]:
          """
          Specifies the offer of the platform image or marketplace image used to create the virtual machine.
          """
          return pulumi.get(self, "offer")
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[str]:
          """
          The image publisher.
          """
          return pulumi.get(self, "publisher")
  
      @property
      @pulumi.getter
      def sku(self) -> Optional[str]:
          """
          The image SKU.
          """
          return pulumi.get(self, "sku")
  
      @property
      @pulumi.getter
      def version(self) -> Optional[str]:
          """
          Specifies the version of the platform image or marketplace image used to create the virtual machine. The allowed formats are Major.Minor.Build or 'latest'. Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest version of an image available at deploy time. Even if you use 'latest', the VM image will not automatically update after deploy time even if a new version becomes available.
          """
          return pulumi.get(self, "version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ImageStorageProfileResponse(dict):
      """
      Describes a storage profile.
      """
      def __init__(__self__, *,
                   data_disks: Optional[Sequence['outputs.ImageDataDiskResponse']] = None,
                   os_disk: Optional['outputs.ImageOSDiskResponse'] = None,
                   zone_resilient: Optional[bool] = None):
          """
          Describes a storage profile.
          :param Sequence['ImageDataDiskResponseArgs'] data_disks: Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          :param 'ImageOSDiskResponseArgs' os_disk: Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          :param bool zone_resilient: Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
          """
          if data_disks is not None:
              pulumi.set(__self__, "data_disks", data_disks)
          if os_disk is not None:
              pulumi.set(__self__, "os_disk", os_disk)
          if zone_resilient is not None:
              pulumi.set(__self__, "zone_resilient", zone_resilient)
  
      @property
      @pulumi.getter(name="dataDisks")
      def data_disks(self) -> Optional[Sequence['outputs.ImageDataDiskResponse']]:
          """
          Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "data_disks")
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional['outputs.ImageOSDiskResponse']:
          """
          Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "os_disk")
  
      @property
      @pulumi.getter(name="zoneResilient")
      def zone_resilient(self) -> Optional[bool]:
          """
          Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
          """
          return pulumi.get(self, "zone_resilient")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class InnerErrorResponse(dict):
      """
      Inner error details.
      """
      def __init__(__self__, *,
                   errordetail: Optional[str] = None,
                   exceptiontype: Optional[str] = None):
          """
          Inner error details.
          :param str errordetail: The internal error message or exception dump.
          :param str exceptiontype: The exception type.
          """
          if errordetail is not None:
              pulumi.set(__self__, "errordetail", errordetail)
          if exceptiontype is not None:
              pulumi.set(__self__, "exceptiontype", exceptiontype)
  
      @property
      @pulumi.getter
      def errordetail(self) -> Optional[str]:
          """
          The internal error message or exception dump.
          """
          return pulumi.get(self, "errordetail")
  
      @property
      @pulumi.getter
      def exceptiontype(self) -> Optional[str]:
          """
          The exception type.
          """
          return pulumi.get(self, "exceptiontype")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class InstanceViewStatusResponse(dict):
      """
      Instance view status.
      """
      def __init__(__self__, *,
                   code: Optional[str] = None,
                   display_status: Optional[str] = None,
                   level: Optional[str] = None,
                   message: Optional[str] = None,
                   time: Optional[str] = None):
          """
          Instance view status.
          :param str code: The status code.
          :param str display_status: The short localizable label for the status.
          :param str level: The level code.
          :param str message: The detailed status message, including for alerts and error messages.
          :param str time: The time of the status.
          """
          if code is not None:
              pulumi.set(__self__, "code", code)
          if display_status is not None:
              pulumi.set(__self__, "display_status", display_status)
          if level is not None:
              pulumi.set(__self__, "level", level)
          if message is not None:
              pulumi.set(__self__, "message", message)
          if time is not None:
              pulumi.set(__self__, "time", time)
  
      @property
      @pulumi.getter
      def code(self) -> Optional[str]:
          """
          The status code.
          """
          return pulumi.get(self, "code")
  
      @property
      @pulumi.getter(name="displayStatus")
      def display_status(self) -> Optional[str]:
          """
          The short localizable label for the status.
          """
          return pulumi.get(self, "display_status")
  
      @property
      @pulumi.getter
      def level(self) -> Optional[str]:
          """
          The level code.
          """
          return pulumi.get(self, "level")
  
      @property
      @pulumi.getter
      def message(self) -> Optional[str]:
          """
          The detailed status message, including for alerts and error messages.
          """
          return pulumi.get(self, "message")
  
      @property
      @pulumi.getter
      def time(self) -> Optional[str]:
          """
          The time of the status.
          """
          return pulumi.get(self, "time")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class KeyForDiskEncryptionSetResponse(dict):
      """
      Key Vault Key Url to be used for server side encryption of Managed Disks and Snapshots
      """
      def __init__(__self__, *,
                   key_url: str,
                   source_vault: Optional['outputs.SourceVaultResponse'] = None):
          """
          Key Vault Key Url to be used for server side encryption of Managed Disks and Snapshots
          :param str key_url: Fully versioned Key Url pointing to a key in KeyVault
          :param 'SourceVaultResponseArgs' source_vault: Resource id of the KeyVault containing the key or secret. This property is optional and cannot be used if the KeyVault subscription is not the same as the Disk Encryption Set subscription.
          """
          pulumi.set(__self__, "key_url", key_url)
          if source_vault is not None:
              pulumi.set(__self__, "source_vault", source_vault)
  
      @property
      @pulumi.getter(name="keyUrl")
      def key_url(self) -> str:
          """
          Fully versioned Key Url pointing to a key in KeyVault
          """
          return pulumi.get(self, "key_url")
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> Optional['outputs.SourceVaultResponse']:
          """
          Resource id of the KeyVault containing the key or secret. This property is optional and cannot be used if the KeyVault subscription is not the same as the Disk Encryption Set subscription.
          """
          return pulumi.get(self, "source_vault")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class KeyVaultAndKeyReferenceResponse(dict):
      """
      Key Vault Key Url and vault id of KeK, KeK is optional and when provided is used to unwrap the encryptionKey
      """
      def __init__(__self__, *,
                   key_url: str,
                   source_vault: 'outputs.SourceVaultResponse'):
          """
          Key Vault Key Url and vault id of KeK, KeK is optional and when provided is used to unwrap the encryptionKey
          :param str key_url: Url pointing to a key or secret in KeyVault
          :param 'SourceVaultResponseArgs' source_vault: Resource id of the KeyVault containing the key or secret
          """
          pulumi.set(__self__, "key_url", key_url)
          pulumi.set(__self__, "source_vault", source_vault)
  
      @property
      @pulumi.getter(name="keyUrl")
      def key_url(self) -> str:
          """
          Url pointing to a key or secret in KeyVault
          """
          return pulumi.get(self, "key_url")
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> 'outputs.SourceVaultResponse':
          """
          Resource id of the KeyVault containing the key or secret
          """
          return pulumi.get(self, "source_vault")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class KeyVaultAndSecretReferenceResponse(dict):
      """
      Key Vault Secret Url and vault id of the encryption key 
      """
      def __init__(__self__, *,
                   secret_url: str,
                   source_vault: 'outputs.SourceVaultResponse'):
          """
          Key Vault Secret Url and vault id of the encryption key 
          :param str secret_url: Url pointing to a key or secret in KeyVault
          :param 'SourceVaultResponseArgs' source_vault: Resource id of the KeyVault containing the key or secret
          """
          pulumi.set(__self__, "secret_url", secret_url)
          pulumi.set(__self__, "source_vault", source_vault)
  
      @property
      @pulumi.getter(name="secretUrl")
      def secret_url(self) -> str:
          """
          Url pointing to a key or secret in KeyVault
          """
          return pulumi.get(self, "secret_url")
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> 'outputs.SourceVaultResponse':
          """
          Resource id of the KeyVault containing the key or secret
          """
          return pulumi.get(self, "source_vault")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class KeyVaultKeyReferenceResponse(dict):
      """
      Describes a reference to Key Vault Key
      """
      def __init__(__self__, *,
                   key_url: str,
                   source_vault: 'outputs.SubResourceResponse'):
          """
          Describes a reference to Key Vault Key
          :param str key_url: The URL referencing a key encryption key in Key Vault.
          :param 'SubResourceResponseArgs' source_vault: The relative URL of the Key Vault containing the key.
          """
          pulumi.set(__self__, "key_url", key_url)
          pulumi.set(__self__, "source_vault", source_vault)
  
      @property
      @pulumi.getter(name="keyUrl")
      def key_url(self) -> str:
          """
          The URL referencing a key encryption key in Key Vault.
          """
          return pulumi.get(self, "key_url")
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> 'outputs.SubResourceResponse':
          """
          The relative URL of the Key Vault containing the key.
          """
          return pulumi.get(self, "source_vault")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class KeyVaultSecretReferenceResponse(dict):
      """
      Describes a reference to Key Vault Secret
      """
      def __init__(__self__, *,
                   secret_url: str,
                   source_vault: 'outputs.SubResourceResponse'):
          """
          Describes a reference to Key Vault Secret
          :param str secret_url: The URL referencing a secret in a Key Vault.
          :param 'SubResourceResponseArgs' source_vault: The relative URL of the Key Vault containing the secret.
          """
          pulumi.set(__self__, "secret_url", secret_url)
          pulumi.set(__self__, "source_vault", source_vault)
  
      @property
      @pulumi.getter(name="secretUrl")
      def secret_url(self) -> str:
          """
          The URL referencing a secret in a Key Vault.
          """
          return pulumi.get(self, "secret_url")
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> 'outputs.SubResourceResponse':
          """
          The relative URL of the Key Vault containing the secret.
          """
          return pulumi.get(self, "source_vault")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class LastPatchInstallationSummaryResponse(dict):
      """
      Describes the properties of the last installed patch summary.
      """
      def __init__(__self__, *,
                   error: 'outputs.ApiErrorResponse',
                   excluded_patch_count: int,
                   failed_patch_count: int,
                   installation_activity_id: str,
                   installed_patch_count: int,
                   last_modified_time: str,
                   maintenance_window_exceeded: bool,
                   not_selected_patch_count: int,
                   pending_patch_count: int,
                   start_time: str,
                   status: str):
          """
          Describes the properties of the last installed patch summary.
          :param 'ApiErrorResponseArgs' error: The errors that were encountered during execution of the operation. The details array contains the list of them.
          :param int excluded_patch_count: The number of all available patches but excluded explicitly by a customer-specified exclusion list match.
          :param int failed_patch_count: The count of patches that failed installation.
          :param str installation_activity_id: The activity ID of the operation that produced this result. It is used to correlate across CRP and extension logs.
          :param int installed_patch_count: The count of patches that successfully installed.
          :param str last_modified_time: The UTC timestamp when the operation began.
          :param bool maintenance_window_exceeded: Describes whether the operation ran out of time before it completed all its intended actions
          :param int not_selected_patch_count: The number of all available patches but not going to be installed because it didn't match a classification or inclusion list entry.
          :param int pending_patch_count: The number of all available patches expected to be installed over the course of the patch installation operation.
          :param str start_time: The UTC timestamp when the operation began.
          :param str status: The overall success or failure status of the operation. It remains "InProgress" until the operation completes. At that point it will become "Unknown", "Failed", "Succeeded", or "CompletedWithWarnings."
          """
          pulumi.set(__self__, "error", error)
          pulumi.set(__self__, "excluded_patch_count", excluded_patch_count)
          pulumi.set(__self__, "failed_patch_count", failed_patch_count)
          pulumi.set(__self__, "installation_activity_id", installation_activity_id)
          pulumi.set(__self__, "installed_patch_count", installed_patch_count)
          pulumi.set(__self__, "last_modified_time", last_modified_time)
          pulumi.set(__self__, "maintenance_window_exceeded", maintenance_window_exceeded)
          pulumi.set(__self__, "not_selected_patch_count", not_selected_patch_count)
          pulumi.set(__self__, "pending_patch_count", pending_patch_count)
          pulumi.set(__self__, "start_time", start_time)
          pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter
      def error(self) -> 'outputs.ApiErrorResponse':
          """
          The errors that were encountered during execution of the operation. The details array contains the list of them.
          """
          return pulumi.get(self, "error")
  
      @property
      @pulumi.getter(name="excludedPatchCount")
      def excluded_patch_count(self) -> int:
          """
          The number of all available patches but excluded explicitly by a customer-specified exclusion list match.
          """
          return pulumi.get(self, "excluded_patch_count")
  
      @property
      @pulumi.getter(name="failedPatchCount")
      def failed_patch_count(self) -> int:
          """
          The count of patches that failed installation.
          """
          return pulumi.get(self, "failed_patch_count")
  
      @property
      @pulumi.getter(name="installationActivityId")
      def installation_activity_id(self) -> str:
          """
          The activity ID of the operation that produced this result. It is used to correlate across CRP and extension logs.
          """
          return pulumi.get(self, "installation_activity_id")
  
      @property
      @pulumi.getter(name="installedPatchCount")
      def installed_patch_count(self) -> int:
          """
          The count of patches that successfully installed.
          """
          return pulumi.get(self, "installed_patch_count")
  
      @property
      @pulumi.getter(name="lastModifiedTime")
      def last_modified_time(self) -> str:
          """
          The UTC timestamp when the operation began.
          """
          return pulumi.get(self, "last_modified_time")
  
      @property
      @pulumi.getter(name="maintenanceWindowExceeded")
      def maintenance_window_exceeded(self) -> bool:
          """
          Describes whether the operation ran out of time before it completed all its intended actions
          """
          return pulumi.get(self, "maintenance_window_exceeded")
  
      @property
      @pulumi.getter(name="notSelectedPatchCount")
      def not_selected_patch_count(self) -> int:
          """
          The number of all available patches but not going to be installed because it didn't match a classification or inclusion list entry.
          """
          return pulumi.get(self, "not_selected_patch_count")
  
      @property
      @pulumi.getter(name="pendingPatchCount")
      def pending_patch_count(self) -> int:
          """
          The number of all available patches expected to be installed over the course of the patch installation operation.
          """
          return pulumi.get(self, "pending_patch_count")
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> str:
          """
          The UTC timestamp when the operation began.
          """
          return pulumi.get(self, "start_time")
  
      @property
      @pulumi.getter
      def status(self) -> str:
          """
          The overall success or failure status of the operation. It remains "InProgress" until the operation completes. At that point it will become "Unknown", "Failed", "Succeeded", or "CompletedWithWarnings."
          """
          return pulumi.get(self, "status")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class LinuxConfigurationResponse(dict):
      """
      Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
      """
      def __init__(__self__, *,
                   disable_password_authentication: Optional[bool] = None,
                   patch_settings: Optional['outputs.LinuxPatchSettingsResponse'] = None,
                   provision_vm_agent: Optional[bool] = None,
                   ssh: Optional['outputs.SshConfigurationResponse'] = None):
          """
          Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          :param bool disable_password_authentication: Specifies whether password authentication should be disabled.
          :param 'LinuxPatchSettingsResponseArgs' patch_settings: [Preview Feature] Specifies settings related to VM Guest Patching on Linux.
          :param bool provision_vm_agent: Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true.  This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
          :param 'SshConfigurationResponseArgs' ssh: Specifies the ssh key configuration for a Linux OS.
          """
          if disable_password_authentication is not None:
              pulumi.set(__self__, "disable_password_authentication", disable_password_authentication)
          if patch_settings is not None:
              pulumi.set(__self__, "patch_settings", patch_settings)
          if provision_vm_agent is not None:
              pulumi.set(__self__, "provision_vm_agent", provision_vm_agent)
          if ssh is not None:
              pulumi.set(__self__, "ssh", ssh)
  
      @property
      @pulumi.getter(name="disablePasswordAuthentication")
      def disable_password_authentication(self) -> Optional[bool]:
          """
          Specifies whether password authentication should be disabled.
          """
          return pulumi.get(self, "disable_password_authentication")
  
      @property
      @pulumi.getter(name="patchSettings")
      def patch_settings(self) -> Optional['outputs.LinuxPatchSettingsResponse']:
          """
          [Preview Feature] Specifies settings related to VM Guest Patching on Linux.
          """
          return pulumi.get(self, "patch_settings")
  
      @property
      @pulumi.getter(name="provisionVMAgent")
      def provision_vm_agent(self) -> Optional[bool]:
          """
          Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true.  This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
          """
          return pulumi.get(self, "provision_vm_agent")
  
      @property
      @pulumi.getter
      def ssh(self) -> Optional['outputs.SshConfigurationResponse']:
          """
          Specifies the ssh key configuration for a Linux OS.
          """
          return pulumi.get(self, "ssh")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class LinuxPatchSettingsResponse(dict):
      """
      Specifies settings related to VM Guest Patching on Linux.
      """
      def __init__(__self__, *,
                   patch_mode: Optional[str] = None):
          """
          Specifies settings related to VM Guest Patching on Linux.
          :param str patch_mode: Specifies the mode of VM Guest Patching to IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - The virtual machine's default patching configuration is used. <br /><br /> **AutomaticByPlatform** - The virtual machine will be automatically updated by the platform. The property provisionVMAgent must be true
          """
          if patch_mode is not None:
              pulumi.set(__self__, "patch_mode", patch_mode)
  
      @property
      @pulumi.getter(name="patchMode")
      def patch_mode(self) -> Optional[str]:
          """
          Specifies the mode of VM Guest Patching to IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - The virtual machine's default patching configuration is used. <br /><br /> **AutomaticByPlatform** - The virtual machine will be automatically updated by the platform. The property provisionVMAgent must be true
          """
          return pulumi.get(self, "patch_mode")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class LogAnalyticsOutputResponseResult(dict):
      """
      LogAnalytics output properties
      """
      def __init__(__self__, *,
                   output: str):
          """
          LogAnalytics output properties
          :param str output: Output file Uri path to blob container.
          """
          pulumi.set(__self__, "output", output)
  
      @property
      @pulumi.getter
      def output(self) -> str:
          """
          Output file Uri path to blob container.
          """
          return pulumi.get(self, "output")
  
  
  @pulumi.output_type
  class MaintenanceRedeployStatusResponse(dict):
      """
      Maintenance Operation Status.
      """
      def __init__(__self__, *,
                   is_customer_initiated_maintenance_allowed: Optional[bool] = None,
                   last_operation_message: Optional[str] = None,
                   last_operation_result_code: Optional[str] = None,
                   maintenance_window_end_time: Optional[str] = None,
                   maintenance_window_start_time: Optional[str] = None,
                   pre_maintenance_window_end_time: Optional[str] = None,
                   pre_maintenance_window_start_time: Optional[str] = None):
          """
          Maintenance Operation Status.
          :param bool is_customer_initiated_maintenance_allowed: True, if customer is allowed to perform Maintenance.
          :param str last_operation_message: Message returned for the last Maintenance Operation.
          :param str last_operation_result_code: The Last Maintenance Operation Result Code.
          :param str maintenance_window_end_time: End Time for the Maintenance Window.
          :param str maintenance_window_start_time: Start Time for the Maintenance Window.
          :param str pre_maintenance_window_end_time: End Time for the Pre Maintenance Window.
          :param str pre_maintenance_window_start_time: Start Time for the Pre Maintenance Window.
          """
          if is_customer_initiated_maintenance_allowed is not None:
              pulumi.set(__self__, "is_customer_initiated_maintenance_allowed", is_customer_initiated_maintenance_allowed)
          if last_operation_message is not None:
              pulumi.set(__self__, "last_operation_message", last_operation_message)
          if last_operation_result_code is not None:
              pulumi.set(__self__, "last_operation_result_code", last_operation_result_code)
          if maintenance_window_end_time is not None:
              pulumi.set(__self__, "maintenance_window_end_time", maintenance_window_end_time)
          if maintenance_window_start_time is not None:
              pulumi.set(__self__, "maintenance_window_start_time", maintenance_window_start_time)
          if pre_maintenance_window_end_time is not None:
              pulumi.set(__self__, "pre_maintenance_window_end_time", pre_maintenance_window_end_time)
          if pre_maintenance_window_start_time is not None:
              pulumi.set(__self__, "pre_maintenance_window_start_time", pre_maintenance_window_start_time)
  
      @property
      @pulumi.getter(name="isCustomerInitiatedMaintenanceAllowed")
      def is_customer_initiated_maintenance_allowed(self) -> Optional[bool]:
          """
          True, if customer is allowed to perform Maintenance.
          """
          return pulumi.get(self, "is_customer_initiated_maintenance_allowed")
  
      @property
      @pulumi.getter(name="lastOperationMessage")
      def last_operation_message(self) -> Optional[str]:
          """
          Message returned for the last Maintenance Operation.
          """
          return pulumi.get(self, "last_operation_message")
  
      @property
      @pulumi.getter(name="lastOperationResultCode")
      def last_operation_result_code(self) -> Optional[str]:
          """
          The Last Maintenance Operation Result Code.
          """
          return pulumi.get(self, "last_operation_result_code")
  
      @property
      @pulumi.getter(name="maintenanceWindowEndTime")
      def maintenance_window_end_time(self) -> Optional[str]:
          """
          End Time for the Maintenance Window.
          """
          return pulumi.get(self, "maintenance_window_end_time")
  
      @property
      @pulumi.getter(name="maintenanceWindowStartTime")
      def maintenance_window_start_time(self) -> Optional[str]:
          """
          Start Time for the Maintenance Window.
          """
          return pulumi.get(self, "maintenance_window_start_time")
  
      @property
      @pulumi.getter(name="preMaintenanceWindowEndTime")
      def pre_maintenance_window_end_time(self) -> Optional[str]:
          """
          End Time for the Pre Maintenance Window.
          """
          return pulumi.get(self, "pre_maintenance_window_end_time")
  
      @property
      @pulumi.getter(name="preMaintenanceWindowStartTime")
      def pre_maintenance_window_start_time(self) -> Optional[str]:
          """
          Start Time for the Pre Maintenance Window.
          """
          return pulumi.get(self, "pre_maintenance_window_start_time")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ManagedDiskParametersResponse(dict):
      """
      The parameters of a managed disk.
      """
      def __init__(__self__, *,
                   disk_encryption_set: Optional['outputs.DiskEncryptionSetParametersResponse'] = None,
                   id: Optional[str] = None,
                   storage_account_type: Optional[str] = None):
          """
          The parameters of a managed disk.
          :param 'DiskEncryptionSetParametersResponseArgs' disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
          :param str id: Resource Id
          :param str storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          if disk_encryption_set is not None:
              pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional['outputs.DiskEncryptionSetParametersResponse']:
          """
          Specifies the customer managed disk encryption set resource id for the managed disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          return pulumi.get(self, "storage_account_type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class NetworkInterfaceReferenceResponse(dict):
      """
      Describes a network interface reference.
      """
      def __init__(__self__, *,
                   id: Optional[str] = None,
                   primary: Optional[bool] = None):
          """
          Describes a network interface reference.
          :param str id: Resource Id
          :param bool primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if primary is not None:
              pulumi.set(__self__, "primary", primary)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[bool]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class NetworkProfileResponse(dict):
      """
      Specifies the network interfaces of the virtual machine.
      """
      def __init__(__self__, *,
                   network_interfaces: Optional[Sequence['outputs.NetworkInterfaceReferenceResponse']] = None):
          """
          Specifies the network interfaces of the virtual machine.
          :param Sequence['NetworkInterfaceReferenceResponseArgs'] network_interfaces: Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
          """
          if network_interfaces is not None:
              pulumi.set(__self__, "network_interfaces", network_interfaces)
  
      @property
      @pulumi.getter(name="networkInterfaces")
      def network_interfaces(self) -> Optional[Sequence['outputs.NetworkInterfaceReferenceResponse']]:
          """
          Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
          """
          return pulumi.get(self, "network_interfaces")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class OSDiskImageEncryptionResponse(dict):
      """
      Contains encryption settings for an OS disk image.
      """
      def __init__(__self__, *,
                   disk_encryption_set_id: Optional[str] = None):
          """
          Contains encryption settings for an OS disk image.
          :param str disk_encryption_set_id: A relative URI containing the resource ID of the disk encryption set.
          """
          if disk_encryption_set_id is not None:
              pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
  
      @property
      @pulumi.getter(name="diskEncryptionSetId")
      def disk_encryption_set_id(self) -> Optional[str]:
          """
          A relative URI containing the resource ID of the disk encryption set.
          """
          return pulumi.get(self, "disk_encryption_set_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class OSDiskResponse(dict):
      """
      Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
      """
      def __init__(__self__, *,
                   create_option: str,
                   caching: Optional[str] = None,
                   diff_disk_settings: Optional['outputs.DiffDiskSettingsResponse'] = None,
                   disk_size_gb: Optional[int] = None,
                   encryption_settings: Optional['outputs.DiskEncryptionSettingsResponse'] = None,
                   image: Optional['outputs.VirtualHardDiskResponse'] = None,
                   managed_disk: Optional['outputs.ManagedDiskParametersResponse'] = None,
                   name: Optional[str] = None,
                   os_type: Optional[str] = None,
                   vhd: Optional['outputs.VirtualHardDiskResponse'] = None,
                   write_accelerator_enabled: Optional[bool] = None):
          """
          Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          :param str create_option: Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None** for Standard storage. **ReadOnly** for Premium storage.
          :param 'DiffDiskSettingsResponseArgs' diff_disk_settings: Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
          :param int disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'DiskEncryptionSettingsResponseArgs' encryption_settings: Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          :param 'VirtualHardDiskResponseArgs' image: The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
          :param 'ManagedDiskParametersResponseArgs' managed_disk: The managed disk parameters.
          :param str name: The disk name.
          :param str os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          :param 'VirtualHardDiskResponseArgs' vhd: The virtual hard disk.
          :param bool write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          pulumi.set(__self__, "create_option", create_option)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if diff_disk_settings is not None:
              pulumi.set(__self__, "diff_disk_settings", diff_disk_settings)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if encryption_settings is not None:
              pulumi.set(__self__, "encryption_settings", encryption_settings)
          if image is not None:
              pulumi.set(__self__, "image", image)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if os_type is not None:
              pulumi.set(__self__, "os_type", os_type)
          if vhd is not None:
              pulumi.set(__self__, "vhd", vhd)
          if write_accelerator_enabled is not None:
              pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
  
      @property
      @pulumi.getter(name="createOption")
      def create_option(self) -> str:
          """
          Specifies how the virtual machine should be created.<br><br> Possible values are:<br><br> **Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.<br><br> **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          """
          return pulumi.get(self, "create_option")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None** for Standard storage. **ReadOnly** for Premium storage.
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="diffDiskSettings")
      def diff_disk_settings(self) -> Optional['outputs.DiffDiskSettingsResponse']:
          """
          Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
          """
          return pulumi.get(self, "diff_disk_settings")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter(name="encryptionSettings")
      def encryption_settings(self) -> Optional['outputs.DiskEncryptionSettingsResponse']:
          """
          Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          """
          return pulumi.get(self, "encryption_settings")
  
      @property
      @pulumi.getter
      def image(self) -> Optional['outputs.VirtualHardDiskResponse']:
          """
          The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
          """
          return pulumi.get(self, "image")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.ManagedDiskParametersResponse']:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> Optional[str]:
          """
          This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          """
          return pulumi.get(self, "os_type")
  
      @property
      @pulumi.getter
      def vhd(self) -> Optional['outputs.VirtualHardDiskResponse']:
          """
          The virtual hard disk.
          """
          return pulumi.get(self, "vhd")
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[bool]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class OSProfileResponse(dict):
      """
      Specifies the operating system settings for the virtual machine. Some of the settings cannot be changed once VM is provisioned.
      """
      def __init__(__self__, *,
                   admin_password: Optional[str] = None,
                   admin_username: Optional[str] = None,
                   allow_extension_operations: Optional[bool] = None,
                   computer_name: Optional[str] = None,
                   custom_data: Optional[str] = None,
                   linux_configuration: Optional['outputs.LinuxConfigurationResponse'] = None,
                   require_guest_provision_signal: Optional[bool] = None,
                   secrets: Optional[Sequence['outputs.VaultSecretGroupResponse']] = None,
                   windows_configuration: Optional['outputs.WindowsConfigurationResponse'] = None):
          """
          Specifies the operating system settings for the virtual machine. Some of the settings cannot be changed once VM is provisioned.
          :param str admin_password: Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
          :param str admin_username: Specifies the name of the administrator account. <br><br> This property cannot be updated after the VM is created. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1  character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters  <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          :param bool allow_extension_operations: Specifies whether extension operations should be allowed on the virtual machine. <br><br>This may only be set to False when no extensions are present on the virtual machine.
          :param str computer_name: Specifies the host OS name of the virtual machine. <br><br> This name cannot be updated after the VM is created. <br><br> **Max-length (Windows):** 15 characters <br><br> **Max-length (Linux):** 64 characters. <br><br> For naming conventions and restrictions see [Azure infrastructure services implementation guidelines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-infrastructure-subscription-accounts-guidelines?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#1-naming-conventions).
          :param str custom_data: Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> **Note: Do not pass any secrets or passwords in customData property** <br><br> This property cannot be updated after the VM is created. <br><br> customData is passed to the VM to be saved as a file, for more information see [Custom Data on Azure VMs](https://azure.microsoft.com/en-us/blog/custom-data-and-cloud-init-on-windows-azure/) <br><br> For using cloud-init for your Linux VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          :param 'LinuxConfigurationResponseArgs' linux_configuration: Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          :param bool require_guest_provision_signal: Specifies whether the guest provision signal is required to infer provision success of the virtual machine.  **Note: This property is for private testing only, and all customers must not set the property to false.**
          :param Sequence['VaultSecretGroupResponseArgs'] secrets: Specifies set of certificates that should be installed onto the virtual machine.
          :param 'WindowsConfigurationResponseArgs' windows_configuration: Specifies Windows operating system settings on the virtual machine.
          """
          if admin_password is not None:
              pulumi.set(__self__, "admin_password", admin_password)
          if admin_username is not None:
              pulumi.set(__self__, "admin_username", admin_username)
          if allow_extension_operations is not None:
              pulumi.set(__self__, "allow_extension_operations", allow_extension_operations)
          if computer_name is not None:
              pulumi.set(__self__, "computer_name", computer_name)
          if custom_data is not None:
              pulumi.set(__self__, "custom_data", custom_data)
          if linux_configuration is not None:
              pulumi.set(__self__, "linux_configuration", linux_configuration)
          if require_guest_provision_signal is not None:
              pulumi.set(__self__, "require_guest_provision_signal", require_guest_provision_signal)
          if secrets is not None:
              pulumi.set(__self__, "secrets", secrets)
          if windows_configuration is not None:
              pulumi.set(__self__, "windows_configuration", windows_configuration)
  
      @property
      @pulumi.getter(name="adminPassword")
      def admin_password(self) -> Optional[str]:
          """
          Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
          """
          return pulumi.get(self, "admin_password")
  
      @property
      @pulumi.getter(name="adminUsername")
      def admin_username(self) -> Optional[str]:
          """
          Specifies the name of the administrator account. <br><br> This property cannot be updated after the VM is created. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1  character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters  <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          """
          return pulumi.get(self, "admin_username")
  
      @property
      @pulumi.getter(name="allowExtensionOperations")
      def allow_extension_operations(self) -> Optional[bool]:
          """
          Specifies whether extension operations should be allowed on the virtual machine. <br><br>This may only be set to False when no extensions are present on the virtual machine.
          """
          return pulumi.get(self, "allow_extension_operations")
  
      @property
      @pulumi.getter(name="computerName")
      def computer_name(self) -> Optional[str]:
          """
          Specifies the host OS name of the virtual machine. <br><br> This name cannot be updated after the VM is created. <br><br> **Max-length (Windows):** 15 characters <br><br> **Max-length (Linux):** 64 characters. <br><br> For naming conventions and restrictions see [Azure infrastructure services implementation guidelines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-infrastructure-subscription-accounts-guidelines?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#1-naming-conventions).
          """
          return pulumi.get(self, "computer_name")
  
      @property
      @pulumi.getter(name="customData")
      def custom_data(self) -> Optional[str]:
          """
          Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> **Note: Do not pass any secrets or passwords in customData property** <br><br> This property cannot be updated after the VM is created. <br><br> customData is passed to the VM to be saved as a file, for more information see [Custom Data on Azure VMs](https://azure.microsoft.com/en-us/blog/custom-data-and-cloud-init-on-windows-azure/) <br><br> For using cloud-init for your Linux VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          """
          return pulumi.get(self, "custom_data")
  
      @property
      @pulumi.getter(name="linuxConfiguration")
      def linux_configuration(self) -> Optional['outputs.LinuxConfigurationResponse']:
          """
          Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          """
          return pulumi.get(self, "linux_configuration")
  
      @property
      @pulumi.getter(name="requireGuestProvisionSignal")
      def require_guest_provision_signal(self) -> Optional[bool]:
          """
          Specifies whether the guest provision signal is required to infer provision success of the virtual machine.  **Note: This property is for private testing only, and all customers must not set the property to false.**
          """
          return pulumi.get(self, "require_guest_provision_signal")
  
      @property
      @pulumi.getter
      def secrets(self) -> Optional[Sequence['outputs.VaultSecretGroupResponse']]:
          """
          Specifies set of certificates that should be installed onto the virtual machine.
          """
          return pulumi.get(self, "secrets")
  
      @property
      @pulumi.getter(name="windowsConfiguration")
      def windows_configuration(self) -> Optional['outputs.WindowsConfigurationResponse']:
          """
          Specifies Windows operating system settings on the virtual machine.
          """
          return pulumi.get(self, "windows_configuration")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PatchSettingsResponse(dict):
      """
      Specifies settings related to VM Guest Patching on Windows.
      """
      def __init__(__self__, *,
                   enable_hotpatching: Optional[bool] = None,
                   patch_mode: Optional[str] = None):
          """
          Specifies settings related to VM Guest Patching on Windows.
          :param bool enable_hotpatching: Enables customers to patch their Azure VMs without requiring a reboot. For enableHotpatching, the 'provisionVMAgent' must be set to true and 'patchMode' must be set to 'AutomaticByPlatform'.
          :param str patch_mode: Specifies the mode of VM Guest Patching to IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **Manual** - You  control the application of patches to a virtual machine. You do this by applying patches manually inside the VM. In this mode, automatic updates are disabled; the property WindowsConfiguration.enableAutomaticUpdates must be false<br /><br /> **AutomaticByOS** - The virtual machine will automatically be updated by the OS. The property WindowsConfiguration.enableAutomaticUpdates must be true. <br /><br /> **AutomaticByPlatform** - the virtual machine will automatically updated by the platform. The properties provisionVMAgent and WindowsConfiguration.enableAutomaticUpdates must be true 
          """
          if enable_hotpatching is not None:
              pulumi.set(__self__, "enable_hotpatching", enable_hotpatching)
          if patch_mode is not None:
              pulumi.set(__self__, "patch_mode", patch_mode)
  
      @property
      @pulumi.getter(name="enableHotpatching")
      def enable_hotpatching(self) -> Optional[bool]:
          """
          Enables customers to patch their Azure VMs without requiring a reboot. For enableHotpatching, the 'provisionVMAgent' must be set to true and 'patchMode' must be set to 'AutomaticByPlatform'.
          """
          return pulumi.get(self, "enable_hotpatching")
  
      @property
      @pulumi.getter(name="patchMode")
      def patch_mode(self) -> Optional[str]:
          """
          Specifies the mode of VM Guest Patching to IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **Manual** - You  control the application of patches to a virtual machine. You do this by applying patches manually inside the VM. In this mode, automatic updates are disabled; the property WindowsConfiguration.enableAutomaticUpdates must be false<br /><br /> **AutomaticByOS** - The virtual machine will automatically be updated by the OS. The property WindowsConfiguration.enableAutomaticUpdates must be true. <br /><br /> **AutomaticByPlatform** - the virtual machine will automatically updated by the platform. The properties provisionVMAgent and WindowsConfiguration.enableAutomaticUpdates must be true 
          """
          return pulumi.get(self, "patch_mode")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PlanResponse(dict):
      """
      Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use.  In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
      """
      def __init__(__self__, *,
                   name: Optional[str] = None,
                   product: Optional[str] = None,
                   promotion_code: Optional[str] = None,
                   publisher: Optional[str] = None):
          """
          Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use.  In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
          :param str name: The plan ID.
          :param str product: Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
          :param str promotion_code: The promotion code.
          :param str publisher: The publisher ID.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
          if product is not None:
              pulumi.set(__self__, "product", product)
          if promotion_code is not None:
              pulumi.set(__self__, "promotion_code", promotion_code)
          if publisher is not None:
              pulumi.set(__self__, "publisher", publisher)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The plan ID.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def product(self) -> Optional[str]:
          """
          Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
          """
          return pulumi.get(self, "product")
  
      @property
      @pulumi.getter(name="promotionCode")
      def promotion_code(self) -> Optional[str]:
          """
          The promotion code.
          """
          return pulumi.get(self, "promotion_code")
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[str]:
          """
          The publisher ID.
          """
          return pulumi.get(self, "publisher")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PrivateEndpointConnectionResponse(dict):
      """
      The Private Endpoint Connection resource.
      """
      def __init__(__self__, *,
                   id: str,
                   name: str,
                   private_link_service_connection_state: 'outputs.PrivateLinkServiceConnectionStateResponse',
                   provisioning_state: str,
                   type: str,
                   private_endpoint: Optional['outputs.PrivateEndpointResponse'] = None):
          """
          The Private Endpoint Connection resource.
          :param str id: private endpoint connection Id
          :param str name: private endpoint connection name
          :param 'PrivateLinkServiceConnectionStateResponseArgs' private_link_service_connection_state: A collection of information about the state of the connection between DiskAccess and Virtual Network.
          :param str provisioning_state: The provisioning state of the private endpoint connection resource.
          :param str type: private endpoint connection type
          :param 'PrivateEndpointResponseArgs' private_endpoint: The resource of private end point.
          """
          pulumi.set(__self__, "id", id)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
          pulumi.set(__self__, "provisioning_state", provisioning_state)
          pulumi.set(__self__, "type", type)
          if private_endpoint is not None:
              pulumi.set(__self__, "private_endpoint", private_endpoint)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          private endpoint connection Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          private endpoint connection name
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="privateLinkServiceConnectionState")
      def private_link_service_connection_state(self) -> 'outputs.PrivateLinkServiceConnectionStateResponse':
          """
          A collection of information about the state of the connection between DiskAccess and Virtual Network.
          """
          return pulumi.get(self, "private_link_service_connection_state")
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> str:
          """
          The provisioning state of the private endpoint connection resource.
          """
          return pulumi.get(self, "provisioning_state")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          private endpoint connection type
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="privateEndpoint")
      def private_endpoint(self) -> Optional['outputs.PrivateEndpointResponse']:
          """
          The resource of private end point.
          """
          return pulumi.get(self, "private_endpoint")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PrivateEndpointResponse(dict):
      """
      The Private Endpoint resource.
      """
      def __init__(__self__, *,
                   id: str):
          """
          The Private Endpoint resource.
          :param str id: The ARM identifier for Private Endpoint
          """
          pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          The ARM identifier for Private Endpoint
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PrivateLinkServiceConnectionStateResponse(dict):
      """
      A collection of information about the state of the connection between service consumer and provider.
      """
      def __init__(__self__, *,
                   actions_required: Optional[str] = None,
                   description: Optional[str] = None,
                   status: Optional[str] = None):
          """
          A collection of information about the state of the connection between service consumer and provider.
          :param str actions_required: A message indicating if changes on the service provider require any updates on the consumer.
          :param str description: The reason for approval/rejection of the connection.
          :param str status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
          """
          if actions_required is not None:
              pulumi.set(__self__, "actions_required", actions_required)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if status is not None:
              pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter(name="actionsRequired")
      def actions_required(self) -> Optional[str]:
          """
          A message indicating if changes on the service provider require any updates on the consumer.
          """
          return pulumi.get(self, "actions_required")
  
      @property
      @pulumi.getter
      def description(self) -> Optional[str]:
          """
          The reason for approval/rejection of the connection.
          """
          return pulumi.get(self, "description")
  
      @property
      @pulumi.getter
      def status(self) -> Optional[str]:
          """
          Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
          """
          return pulumi.get(self, "status")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class PurchasePlanResponse(dict):
      """
      Used for establishing the purchase context of any 3rd Party artifact through MarketPlace.
      """
      def __init__(__self__, *,
                   name: str,
                   product: str,
                   publisher: str,
                   promotion_code: Optional[str] = None):
          """
          Used for establishing the purchase context of any 3rd Party artifact through MarketPlace.
          :param str name: The plan ID.
          :param str product: Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
          :param str publisher: The publisher ID.
          :param str promotion_code: The Offer Promotion Code.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "product", product)
          pulumi.set(__self__, "publisher", publisher)
          if promotion_code is not None:
              pulumi.set(__self__, "promotion_code", promotion_code)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The plan ID.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def product(self) -> str:
          """
          Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
          """
          return pulumi.get(self, "product")
  
      @property
      @pulumi.getter
      def publisher(self) -> str:
          """
          The publisher ID.
          """
          return pulumi.get(self, "publisher")
  
      @property
      @pulumi.getter(name="promotionCode")
      def promotion_code(self) -> Optional[str]:
          """
          The Offer Promotion Code.
          """
          return pulumi.get(self, "promotion_code")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class RecommendedMachineConfigurationResponse(dict):
      """
      The properties describe the recommended machine configuration for this Image Definition. These properties are updatable.
      """
      def __init__(__self__, *,
                   memory: Optional['outputs.ResourceRangeResponse'] = None,
                   v_cpus: Optional['outputs.ResourceRangeResponse'] = None):
          """
          The properties describe the recommended machine configuration for this Image Definition. These properties are updatable.
          :param 'ResourceRangeResponseArgs' memory: Describes the resource range.
          :param 'ResourceRangeResponseArgs' v_cpus: Describes the resource range.
          """
          if memory is not None:
              pulumi.set(__self__, "memory", memory)
          if v_cpus is not None:
              pulumi.set(__self__, "v_cpus", v_cpus)
  
      @property
      @pulumi.getter
      def memory(self) -> Optional['outputs.ResourceRangeResponse']:
          """
          Describes the resource range.
          """
          return pulumi.get(self, "memory")
  
      @property
      @pulumi.getter(name="vCPUs")
      def v_cpus(self) -> Optional['outputs.ResourceRangeResponse']:
          """
          Describes the resource range.
          """
          return pulumi.get(self, "v_cpus")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class RegionalReplicationStatusResponse(dict):
      """
      This is the regional replication status.
      """
      def __init__(__self__, *,
                   details: str,
                   progress: int,
                   region: str,
                   state: str):
          """
          This is the regional replication status.
          :param str details: The details of the replication status.
          :param int progress: It indicates progress of the replication job.
          :param str region: The region to which the gallery image version is being replicated to.
          :param str state: This is the regional replication state.
          """
          pulumi.set(__self__, "details", details)
          pulumi.set(__self__, "progress", progress)
          pulumi.set(__self__, "region", region)
          pulumi.set(__self__, "state", state)
  
      @property
      @pulumi.getter
      def details(self) -> str:
          """
          The details of the replication status.
          """
          return pulumi.get(self, "details")
  
      @property
      @pulumi.getter
      def progress(self) -> int:
          """
          It indicates progress of the replication job.
          """
          return pulumi.get(self, "progress")
  
      @property
      @pulumi.getter
      def region(self) -> str:
          """
          The region to which the gallery image version is being replicated to.
          """
          return pulumi.get(self, "region")
  
      @property
      @pulumi.getter
      def state(self) -> str:
          """
          This is the regional replication state.
          """
          return pulumi.get(self, "state")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ReplicationStatusResponse(dict):
      """
      This is the replication status of the gallery image version.
      """
      def __init__(__self__, *,
                   aggregated_state: str,
                   summary: Sequence['outputs.RegionalReplicationStatusResponse']):
          """
          This is the replication status of the gallery image version.
          :param str aggregated_state: This is the aggregated replication status based on all the regional replication status flags.
          :param Sequence['RegionalReplicationStatusResponseArgs'] summary: This is a summary of replication status for each region.
          """
          pulumi.set(__self__, "aggregated_state", aggregated_state)
          pulumi.set(__self__, "summary", summary)
  
      @property
      @pulumi.getter(name="aggregatedState")
      def aggregated_state(self) -> str:
          """
          This is the aggregated replication status based on all the regional replication status flags.
          """
          return pulumi.get(self, "aggregated_state")
  
      @property
      @pulumi.getter
      def summary(self) -> Sequence['outputs.RegionalReplicationStatusResponse']:
          """
          This is a summary of replication status for each region.
          """
          return pulumi.get(self, "summary")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ResourceRangeResponse(dict):
      """
      Describes the resource range.
      """
      def __init__(__self__, *,
                   max: Optional[int] = None,
                   min: Optional[int] = None):
          """
          Describes the resource range.
          :param int max: The maximum number of the resource.
          :param int min: The minimum number of the resource.
          """
          if max is not None:
              pulumi.set(__self__, "max", max)
          if min is not None:
              pulumi.set(__self__, "min", min)
  
      @property
      @pulumi.getter
      def max(self) -> Optional[int]:
          """
          The maximum number of the resource.
          """
          return pulumi.get(self, "max")
  
      @property
      @pulumi.getter
      def min(self) -> Optional[int]:
          """
          The minimum number of the resource.
          """
          return pulumi.get(self, "min")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class RollingUpgradePolicyResponse(dict):
      """
      The configuration parameters used while performing a rolling upgrade.
      """
      def __init__(__self__, *,
                   enable_cross_zone_upgrade: Optional[bool] = None,
                   max_batch_instance_percent: Optional[int] = None,
                   max_unhealthy_instance_percent: Optional[int] = None,
                   max_unhealthy_upgraded_instance_percent: Optional[int] = None,
                   pause_time_between_batches: Optional[str] = None,
                   prioritize_unhealthy_instances: Optional[bool] = None):
          """
          The configuration parameters used while performing a rolling upgrade.
          :param bool enable_cross_zone_upgrade: Allow VMSS to ignore AZ boundaries when constructing upgrade batches. Take into consideration the Update Domain and maxBatchInstancePercent to determine the batch size.
          :param int max_batch_instance_percent: The maximum percent of total virtual machine instances that will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or future batches can cause the percentage of instances in a batch to decrease to ensure higher reliability. The default value for this parameter is 20%.
          :param int max_unhealthy_instance_percent: The maximum percentage of the total virtual machine instances in the scale set that can be simultaneously unhealthy, either as a result of being upgraded, or by being found in an unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The default value for this parameter is 20%.
          :param int max_unhealthy_upgraded_instance_percent: The maximum percentage of upgraded virtual machine instances that can be found to be in an unhealthy state. This check will happen after each batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The default value for this parameter is 20%.
          :param str pause_time_between_batches: The wait time between completing the update for all virtual machines in one batch and starting the next batch. The time duration should be specified in ISO 8601 format. The default value is 0 seconds (PT0S).
          :param bool prioritize_unhealthy_instances: Upgrade all unhealthy instances in a scale set before any healthy instances.
          """
          if enable_cross_zone_upgrade is not None:
              pulumi.set(__self__, "enable_cross_zone_upgrade", enable_cross_zone_upgrade)
          if max_batch_instance_percent is not None:
              pulumi.set(__self__, "max_batch_instance_percent", max_batch_instance_percent)
          if max_unhealthy_instance_percent is not None:
              pulumi.set(__self__, "max_unhealthy_instance_percent", max_unhealthy_instance_percent)
          if max_unhealthy_upgraded_instance_percent is not None:
              pulumi.set(__self__, "max_unhealthy_upgraded_instance_percent", max_unhealthy_upgraded_instance_percent)
          if pause_time_between_batches is not None:
              pulumi.set(__self__, "pause_time_between_batches", pause_time_between_batches)
          if prioritize_unhealthy_instances is not None:
              pulumi.set(__self__, "prioritize_unhealthy_instances", prioritize_unhealthy_instances)
  
      @property
      @pulumi.getter(name="enableCrossZoneUpgrade")
      def enable_cross_zone_upgrade(self) -> Optional[bool]:
          """
          Allow VMSS to ignore AZ boundaries when constructing upgrade batches. Take into consideration the Update Domain and maxBatchInstancePercent to determine the batch size.
          """
          return pulumi.get(self, "enable_cross_zone_upgrade")
  
      @property
      @pulumi.getter(name="maxBatchInstancePercent")
      def max_batch_instance_percent(self) -> Optional[int]:
          """
          The maximum percent of total virtual machine instances that will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or future batches can cause the percentage of instances in a batch to decrease to ensure higher reliability. The default value for this parameter is 20%.
          """
          return pulumi.get(self, "max_batch_instance_percent")
  
      @property
      @pulumi.getter(name="maxUnhealthyInstancePercent")
      def max_unhealthy_instance_percent(self) -> Optional[int]:
          """
          The maximum percentage of the total virtual machine instances in the scale set that can be simultaneously unhealthy, either as a result of being upgraded, or by being found in an unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The default value for this parameter is 20%.
          """
          return pulumi.get(self, "max_unhealthy_instance_percent")
  
      @property
      @pulumi.getter(name="maxUnhealthyUpgradedInstancePercent")
      def max_unhealthy_upgraded_instance_percent(self) -> Optional[int]:
          """
          The maximum percentage of upgraded virtual machine instances that can be found to be in an unhealthy state. This check will happen after each batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The default value for this parameter is 20%.
          """
          return pulumi.get(self, "max_unhealthy_upgraded_instance_percent")
  
      @property
      @pulumi.getter(name="pauseTimeBetweenBatches")
      def pause_time_between_batches(self) -> Optional[str]:
          """
          The wait time between completing the update for all virtual machines in one batch and starting the next batch. The time duration should be specified in ISO 8601 format. The default value is 0 seconds (PT0S).
          """
          return pulumi.get(self, "pause_time_between_batches")
  
      @property
      @pulumi.getter(name="prioritizeUnhealthyInstances")
      def prioritize_unhealthy_instances(self) -> Optional[bool]:
          """
          Upgrade all unhealthy instances in a scale set before any healthy instances.
          """
          return pulumi.get(self, "prioritize_unhealthy_instances")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class RunCommandInputParameterResponse(dict):
      """
      Describes the properties of a run command parameter.
      """
      def __init__(__self__, *,
                   name: str,
                   value: str):
          """
          Describes the properties of a run command parameter.
          :param str name: The run command parameter name.
          :param str value: The run command parameter value.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The run command parameter name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          """
          The run command parameter value.
          """
          return pulumi.get(self, "value")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ScaleInPolicyResponse(dict):
      """
      Describes a scale-in policy for a virtual machine scale set.
      """
      def __init__(__self__, *,
                   rules: Optional[Sequence[str]] = None):
          """
          Describes a scale-in policy for a virtual machine scale set.
          :param Sequence[str] rules: The rules to be followed when scaling-in a virtual machine scale set. <br><br> Possible values are: <br><br> **Default** When a virtual machine scale set is scaled in, the scale set will first be balanced across zones if it is a zonal scale set. Then, it will be balanced across Fault Domains as far as possible. Within each Fault Domain, the virtual machines chosen for removal will be the newest ones that are not protected from scale-in. <br><br> **OldestVM** When a virtual machine scale set is being scaled-in, the oldest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the oldest virtual machines that are not protected will be chosen for removal. <br><br> **NewestVM** When a virtual machine scale set is being scaled-in, the newest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the newest virtual machines that are not protected will be chosen for removal. <br><br>
          """
          if rules is not None:
              pulumi.set(__self__, "rules", rules)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[Sequence[str]]:
          """
          The rules to be followed when scaling-in a virtual machine scale set. <br><br> Possible values are: <br><br> **Default** When a virtual machine scale set is scaled in, the scale set will first be balanced across zones if it is a zonal scale set. Then, it will be balanced across Fault Domains as far as possible. Within each Fault Domain, the virtual machines chosen for removal will be the newest ones that are not protected from scale-in. <br><br> **OldestVM** When a virtual machine scale set is being scaled-in, the oldest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the oldest virtual machines that are not protected will be chosen for removal. <br><br> **NewestVM** When a virtual machine scale set is being scaled-in, the newest virtual machines that are not protected from scale-in will be chosen for removal. For zonal virtual machine scale sets, the scale set will first be balanced across zones. Within each zone, the newest virtual machines that are not protected will be chosen for removal. <br><br>
          """
          return pulumi.get(self, "rules")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ScheduledEventsProfileResponse(dict):
      def __init__(__self__, *,
                   terminate_notification_profile: Optional['outputs.TerminateNotificationProfileResponse'] = None):
          """
          :param 'TerminateNotificationProfileResponseArgs' terminate_notification_profile: Specifies Terminate Scheduled Event related configurations.
          """
          if terminate_notification_profile is not None:
              pulumi.set(__self__, "terminate_notification_profile", terminate_notification_profile)
  
      @property
      @pulumi.getter(name="terminateNotificationProfile")
      def terminate_notification_profile(self) -> Optional['outputs.TerminateNotificationProfileResponse']:
          """
          Specifies Terminate Scheduled Event related configurations.
          """
          return pulumi.get(self, "terminate_notification_profile")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SecurityProfileResponse(dict):
      """
      Specifies the Security profile settings for the virtual machine or virtual machine scale set.
      """
      def __init__(__self__, *,
                   encryption_at_host: Optional[bool] = None,
                   security_type: Optional[str] = None,
                   uefi_settings: Optional['outputs.UefiSettingsResponse'] = None):
          """
          Specifies the Security profile settings for the virtual machine or virtual machine scale set.
          :param bool encryption_at_host: This property can be used by user in the request to enable or disable the Host Encryption for the virtual machine or virtual machine scale set. This will enable the encryption for all the disks including Resource/Temp disk at host itself. <br><br> Default: The Encryption at host will be disabled unless this property is set to true for the resource.
          :param str security_type: Specifies the SecurityType of the virtual machine. It is set as TrustedLaunch to enable UefiSettings. <br><br> Default: UefiSettings will not be enabled unless this property is set as TrustedLaunch.
          :param 'UefiSettingsResponseArgs' uefi_settings: Specifies the security settings like secure boot and vTPM used while creating the virtual machine. <br><br>Minimum api-version: 2020-12-01
          """
          if encryption_at_host is not None:
              pulumi.set(__self__, "encryption_at_host", encryption_at_host)
          if security_type is not None:
              pulumi.set(__self__, "security_type", security_type)
          if uefi_settings is not None:
              pulumi.set(__self__, "uefi_settings", uefi_settings)
  
      @property
      @pulumi.getter(name="encryptionAtHost")
      def encryption_at_host(self) -> Optional[bool]:
          """
          This property can be used by user in the request to enable or disable the Host Encryption for the virtual machine or virtual machine scale set. This will enable the encryption for all the disks including Resource/Temp disk at host itself. <br><br> Default: The Encryption at host will be disabled unless this property is set to true for the resource.
          """
          return pulumi.get(self, "encryption_at_host")
  
      @property
      @pulumi.getter(name="securityType")
      def security_type(self) -> Optional[str]:
          """
          Specifies the SecurityType of the virtual machine. It is set as TrustedLaunch to enable UefiSettings. <br><br> Default: UefiSettings will not be enabled unless this property is set as TrustedLaunch.
          """
          return pulumi.get(self, "security_type")
  
      @property
      @pulumi.getter(name="uefiSettings")
      def uefi_settings(self) -> Optional['outputs.UefiSettingsResponse']:
          """
          Specifies the security settings like secure boot and vTPM used while creating the virtual machine. <br><br>Minimum api-version: 2020-12-01
          """
          return pulumi.get(self, "uefi_settings")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ShareInfoElementResponse(dict):
      def __init__(__self__, *,
                   vm_uri: str):
          """
          :param str vm_uri: A relative URI containing the ID of the VM that has the disk attached.
          """
          pulumi.set(__self__, "vm_uri", vm_uri)
  
      @property
      @pulumi.getter(name="vmUri")
      def vm_uri(self) -> str:
          """
          A relative URI containing the ID of the VM that has the disk attached.
          """
          return pulumi.get(self, "vm_uri")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SharingProfileGroupResponse(dict):
      """
      Group of the gallery sharing profile
      """
      def __init__(__self__, *,
                   ids: Optional[Sequence[str]] = None,
                   type: Optional[str] = None):
          """
          Group of the gallery sharing profile
          :param Sequence[str] ids: A list of subscription/tenant ids the gallery is aimed to be shared to.
          :param str type: This property allows you to specify the type of sharing group. <br><br> Possible values are: <br><br> **Subscriptions** <br><br> **AADTenants**
          """
          if ids is not None:
              pulumi.set(__self__, "ids", ids)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def ids(self) -> Optional[Sequence[str]]:
          """
          A list of subscription/tenant ids the gallery is aimed to be shared to.
          """
          return pulumi.get(self, "ids")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          This property allows you to specify the type of sharing group. <br><br> Possible values are: <br><br> **Subscriptions** <br><br> **AADTenants**
          """
          return pulumi.get(self, "type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SharingProfileResponse(dict):
      """
      Profile for gallery sharing to subscription or tenant
      """
      def __init__(__self__, *,
                   groups: Sequence['outputs.SharingProfileGroupResponse'],
                   permissions: Optional[str] = None):
          """
          Profile for gallery sharing to subscription or tenant
          :param Sequence['SharingProfileGroupResponseArgs'] groups: A list of sharing profile groups.
          :param str permissions: This property allows you to specify the permission of sharing gallery. <br><br> Possible values are: <br><br> **Private** <br><br> **Groups**
          """
          pulumi.set(__self__, "groups", groups)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def groups(self) -> Sequence['outputs.SharingProfileGroupResponse']:
          """
          A list of sharing profile groups.
          """
          return pulumi.get(self, "groups")
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[str]:
          """
          This property allows you to specify the permission of sharing gallery. <br><br> Possible values are: <br><br> **Private** <br><br> **Groups**
          """
          return pulumi.get(self, "permissions")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SkuResponse(dict):
      """
      Describes a virtual machine scale set sku. NOTE: If the new VM SKU is not supported on the hardware the scale set is currently on, you need to deallocate the VMs in the scale set before you modify the SKU name.
      """
      def __init__(__self__, *,
                   capacity: Optional[float] = None,
                   name: Optional[str] = None,
                   tier: Optional[str] = None):
          """
          Describes a virtual machine scale set sku. NOTE: If the new VM SKU is not supported on the hardware the scale set is currently on, you need to deallocate the VMs in the scale set before you modify the SKU name.
          :param float capacity: Specifies the number of virtual machines in the scale set.
          :param str name: The sku name.
          :param str tier: Specifies the tier of virtual machines in a scale set.<br /><br /> Possible Values:<br /><br /> **Standard**<br /><br /> **Basic**
          """
          if capacity is not None:
              pulumi.set(__self__, "capacity", capacity)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if tier is not None:
              pulumi.set(__self__, "tier", tier)
  
      @property
      @pulumi.getter
      def capacity(self) -> Optional[float]:
          """
          Specifies the number of virtual machines in the scale set.
          """
          return pulumi.get(self, "capacity")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def tier(self) -> Optional[str]:
          """
          Specifies the tier of virtual machines in a scale set.<br /><br /> Possible Values:<br /><br /> **Standard**<br /><br /> **Basic**
          """
          return pulumi.get(self, "tier")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SnapshotSkuResponse(dict):
      """
      The snapshots sku name. Can be Standard_LRS, Premium_LRS, or Standard_ZRS. This is an optional parameter for incremental snapshot and the default behavior is the SKU will be set to the same sku as the previous snapshot
      """
      def __init__(__self__, *,
                   tier: str,
                   name: Optional[str] = None):
          """
          The snapshots sku name. Can be Standard_LRS, Premium_LRS, or Standard_ZRS. This is an optional parameter for incremental snapshot and the default behavior is the SKU will be set to the same sku as the previous snapshot
          :param str tier: The sku tier.
          :param str name: The sku name.
          """
          pulumi.set(__self__, "tier", tier)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def tier(self) -> str:
          """
          The sku tier.
          """
          return pulumi.get(self, "tier")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SourceVaultResponse(dict):
      """
      The vault id is an Azure Resource Manager Resource id in the form /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}
      """
      def __init__(__self__, *,
                   id: Optional[str] = None):
          """
          The vault id is an Azure Resource Manager Resource id in the form /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}
          :param str id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SshConfigurationResponse(dict):
      """
      SSH configuration for Linux based VMs running on Azure
      """
      def __init__(__self__, *,
                   public_keys: Optional[Sequence['outputs.SshPublicKeyResponse']] = None):
          """
          SSH configuration for Linux based VMs running on Azure
          :param Sequence['SshPublicKeyResponseArgs'] public_keys: The list of SSH public keys used to authenticate with linux based VMs.
          """
          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.SshPublicKeyResponse']]:
          """
          The list of SSH public keys used to authenticate with linux based VMs.
          """
          return pulumi.get(self, "public_keys")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SshPublicKeyResponse(dict):
      """
      Contains information about SSH certificate public key and the path on the Linux VM where the public key is placed.
      """
      def __init__(__self__, *,
                   key_data: Optional[str] = None,
                   path: Optional[str] = None):
          """
          Contains information about SSH certificate public key and the path on the Linux VM where the public key is placed.
          :param str key_data: SSH public key certificate used to authenticate with the VM through ssh. The key needs to be at least 2048-bit and in ssh-rsa format. <br><br> For creating ssh keys, see [Create SSH keys on Linux and Mac for Linux VMs in Azure](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          :param str path: Specifies the full path on the created VM where ssh public key is stored. If the file already exists, the specified key is appended to the file. Example: /home/user/.ssh/authorized_keys
          """
          if key_data is not None:
              pulumi.set(__self__, "key_data", key_data)
          if path is not None:
              pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter(name="keyData")
      def key_data(self) -> Optional[str]:
          """
          SSH public key certificate used to authenticate with the VM through ssh. The key needs to be at least 2048-bit and in ssh-rsa format. <br><br> For creating ssh keys, see [Create SSH keys on Linux and Mac for Linux VMs in Azure](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          """
          return pulumi.get(self, "key_data")
  
      @property
      @pulumi.getter
      def path(self) -> Optional[str]:
          """
          Specifies the full path on the created VM where ssh public key is stored. If the file already exists, the specified key is appended to the file. Example: /home/user/.ssh/authorized_keys
          """
          return pulumi.get(self, "path")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class StorageProfileResponse(dict):
      """
      Specifies the storage settings for the virtual machine disks.
      """
      def __init__(__self__, *,
                   data_disks: Optional[Sequence['outputs.DataDiskResponse']] = None,
                   image_reference: Optional['outputs.ImageReferenceResponse'] = None,
                   os_disk: Optional['outputs.OSDiskResponse'] = None):
          """
          Specifies the storage settings for the virtual machine disks.
          :param Sequence['DataDiskResponseArgs'] data_disks: Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          :param 'ImageReferenceResponseArgs' image_reference: Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
          :param 'OSDiskResponseArgs' os_disk: Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          if data_disks is not None:
              pulumi.set(__self__, "data_disks", data_disks)
          if image_reference is not None:
              pulumi.set(__self__, "image_reference", image_reference)
          if os_disk is not None:
              pulumi.set(__self__, "os_disk", os_disk)
  
      @property
      @pulumi.getter(name="dataDisks")
      def data_disks(self) -> Optional[Sequence['outputs.DataDiskResponse']]:
          """
          Specifies the parameters that are used to add a data disk to a virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "data_disks")
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional['outputs.ImageReferenceResponse']:
          """
          Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
          """
          return pulumi.get(self, "image_reference")
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional['outputs.OSDiskResponse']:
          """
          Specifies information about the operating system disk used by the virtual machine. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "os_disk")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SubResourceReadOnlyResponse(dict):
      def __init__(__self__, *,
                   id: str):
          """
          :param str id: Resource Id
          """
          pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SubResourceResponse(dict):
      def __init__(__self__, *,
                   id: Optional[str] = None):
          """
          :param str id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SubResourceWithColocationStatusResponse(dict):
      def __init__(__self__, *,
                   colocation_status: Optional['outputs.InstanceViewStatusResponse'] = None,
                   id: Optional[str] = None):
          """
          :param 'InstanceViewStatusResponseArgs' colocation_status: Describes colocation status of a resource in the Proximity Placement Group.
          :param str id: Resource Id
          """
          if colocation_status is not None:
              pulumi.set(__self__, "colocation_status", colocation_status)
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter(name="colocationStatus")
      def colocation_status(self) -> Optional['outputs.InstanceViewStatusResponse']:
          """
          Describes colocation status of a resource in the Proximity Placement Group.
          """
          return pulumi.get(self, "colocation_status")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class TargetRegionResponse(dict):
      """
      Describes the target region information.
      """
      def __init__(__self__, *,
                   name: str,
                   encryption: Optional['outputs.EncryptionImagesResponse'] = None,
                   regional_replica_count: Optional[int] = None,
                   storage_account_type: Optional[str] = None):
          """
          Describes the target region information.
          :param str name: The name of the region.
          :param 'EncryptionImagesResponseArgs' encryption: Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
          :param int regional_replica_count: The number of replicas of the Image Version to be created per region. This property is updatable.
          :param str storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          pulumi.set(__self__, "name", name)
          if encryption is not None:
              pulumi.set(__self__, "encryption", encryption)
          if regional_replica_count is not None:
              pulumi.set(__self__, "regional_replica_count", regional_replica_count)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the region.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def encryption(self) -> Optional['outputs.EncryptionImagesResponse']:
          """
          Optional. Allows users to provide customer managed keys for encrypting the OS and data disks in the gallery artifact.
          """
          return pulumi.get(self, "encryption")
  
      @property
      @pulumi.getter(name="regionalReplicaCount")
      def regional_replica_count(self) -> Optional[int]:
          """
          The number of replicas of the Image Version to be created per region. This property is updatable.
          """
          return pulumi.get(self, "regional_replica_count")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class TerminateNotificationProfileResponse(dict):
      def __init__(__self__, *,
                   enable: Optional[bool] = None,
                   not_before_timeout: Optional[str] = None):
          """
          :param bool enable: Specifies whether the Terminate Scheduled event is enabled or disabled.
          :param str not_before_timeout: Configurable length of time a Virtual Machine being deleted will have to potentially approve the Terminate Scheduled Event before the event is auto approved (timed out). The configuration must be specified in ISO 8601 format, the default value is 5 minutes (PT5M)
          """
          if enable is not None:
              pulumi.set(__self__, "enable", enable)
          if not_before_timeout is not None:
              pulumi.set(__self__, "not_before_timeout", not_before_timeout)
  
      @property
      @pulumi.getter
      def enable(self) -> Optional[bool]:
          """
          Specifies whether the Terminate Scheduled event is enabled or disabled.
          """
          return pulumi.get(self, "enable")
  
      @property
      @pulumi.getter(name="notBeforeTimeout")
      def not_before_timeout(self) -> Optional[str]:
          """
          Configurable length of time a Virtual Machine being deleted will have to potentially approve the Terminate Scheduled Event before the event is auto approved (timed out). The configuration must be specified in ISO 8601 format, the default value is 5 minutes (PT5M)
          """
          return pulumi.get(self, "not_before_timeout")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UefiSettingsResponse(dict):
      """
      Specifies the security settings like secure boot and vTPM used while creating the virtual machine. <br><br>Minimum api-version: 2020-12-01
      """
      def __init__(__self__, *,
                   secure_boot_enabled: Optional[bool] = None,
                   v_tpm_enabled: Optional[bool] = None):
          """
          Specifies the security settings like secure boot and vTPM used while creating the virtual machine. <br><br>Minimum api-version: 2020-12-01
          :param bool secure_boot_enabled: Specifies whether secure boot should be enabled on the virtual machine. <br><br>Minimum api-version: 2020-12-01
          :param bool v_tpm_enabled: Specifies whether vTPM should be enabled on the virtual machine. <br><br>Minimum api-version: 2020-12-01
          """
          if secure_boot_enabled is not None:
              pulumi.set(__self__, "secure_boot_enabled", secure_boot_enabled)
          if v_tpm_enabled is not None:
              pulumi.set(__self__, "v_tpm_enabled", v_tpm_enabled)
  
      @property
      @pulumi.getter(name="secureBootEnabled")
      def secure_boot_enabled(self) -> Optional[bool]:
          """
          Specifies whether secure boot should be enabled on the virtual machine. <br><br>Minimum api-version: 2020-12-01
          """
          return pulumi.get(self, "secure_boot_enabled")
  
      @property
      @pulumi.getter(name="vTpmEnabled")
      def v_tpm_enabled(self) -> Optional[bool]:
          """
          Specifies whether vTPM should be enabled on the virtual machine. <br><br>Minimum api-version: 2020-12-01
          """
          return pulumi.get(self, "v_tpm_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UpgradePolicyResponse(dict):
      """
      Describes an upgrade policy - automatic, manual, or rolling.
      """
      def __init__(__self__, *,
                   automatic_os_upgrade_policy: Optional['outputs.AutomaticOSUpgradePolicyResponse'] = None,
                   mode: Optional[str] = None,
                   rolling_upgrade_policy: Optional['outputs.RollingUpgradePolicyResponse'] = None):
          """
          Describes an upgrade policy - automatic, manual, or rolling.
          :param 'AutomaticOSUpgradePolicyResponseArgs' automatic_os_upgrade_policy: Configuration parameters used for performing automatic OS Upgrade.
          :param str mode: Specifies the mode of an upgrade to virtual machines in the scale set.<br /><br /> Possible values are:<br /><br /> **Manual** - You  control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.<br /><br /> **Automatic** - All virtual machines in the scale set are  automatically updated at the same time.
          :param 'RollingUpgradePolicyResponseArgs' rolling_upgrade_policy: The configuration parameters used while performing a rolling upgrade.
          """
          if automatic_os_upgrade_policy is not None:
              pulumi.set(__self__, "automatic_os_upgrade_policy", automatic_os_upgrade_policy)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
          if rolling_upgrade_policy is not None:
              pulumi.set(__self__, "rolling_upgrade_policy", rolling_upgrade_policy)
  
      @property
      @pulumi.getter(name="automaticOSUpgradePolicy")
      def automatic_os_upgrade_policy(self) -> Optional['outputs.AutomaticOSUpgradePolicyResponse']:
          """
          Configuration parameters used for performing automatic OS Upgrade.
          """
          return pulumi.get(self, "automatic_os_upgrade_policy")
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[str]:
          """
          Specifies the mode of an upgrade to virtual machines in the scale set.<br /><br /> Possible values are:<br /><br /> **Manual** - You  control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.<br /><br /> **Automatic** - All virtual machines in the scale set are  automatically updated at the same time.
          """
          return pulumi.get(self, "mode")
  
      @property
      @pulumi.getter(name="rollingUpgradePolicy")
      def rolling_upgrade_policy(self) -> Optional['outputs.RollingUpgradePolicyResponse']:
          """
          The configuration parameters used while performing a rolling upgrade.
          """
          return pulumi.get(self, "rolling_upgrade_policy")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UserArtifactManageResponse(dict):
      def __init__(__self__, *,
                   install: str,
                   remove: str,
                   update: Optional[str] = None):
          """
          :param str install: Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
          :param str remove: Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
          :param str update: Optional. The path and arguments to update the gallery application. If not present, then update operation will invoke remove command on the previous version and install command on the current version of the gallery application. This is limited to 4096 characters.
          """
          pulumi.set(__self__, "install", install)
          pulumi.set(__self__, "remove", remove)
          if update is not None:
              pulumi.set(__self__, "update", update)
  
      @property
      @pulumi.getter
      def install(self) -> str:
          """
          Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
          """
          return pulumi.get(self, "install")
  
      @property
      @pulumi.getter
      def remove(self) -> str:
          """
          Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
          """
          return pulumi.get(self, "remove")
  
      @property
      @pulumi.getter
      def update(self) -> Optional[str]:
          """
          Optional. The path and arguments to update the gallery application. If not present, then update operation will invoke remove command on the previous version and install command on the current version of the gallery application. This is limited to 4096 characters.
          """
          return pulumi.get(self, "update")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UserArtifactSourceResponse(dict):
      """
      The source image from which the Image Version is going to be created.
      """
      def __init__(__self__, *,
                   media_link: str,
                   default_configuration_link: Optional[str] = None):
          """
          The source image from which the Image Version is going to be created.
          :param str media_link: Required. The mediaLink of the artifact, must be a readable storage page blob.
          :param str default_configuration_link: Optional. The defaultConfigurationLink of the artifact, must be a readable storage page blob.
          """
          pulumi.set(__self__, "media_link", media_link)
          if default_configuration_link is not None:
              pulumi.set(__self__, "default_configuration_link", default_configuration_link)
  
      @property
      @pulumi.getter(name="mediaLink")
      def media_link(self) -> str:
          """
          Required. The mediaLink of the artifact, must be a readable storage page blob.
          """
          return pulumi.get(self, "media_link")
  
      @property
      @pulumi.getter(name="defaultConfigurationLink")
      def default_configuration_link(self) -> Optional[str]:
          """
          Optional. The defaultConfigurationLink of the artifact, must be a readable storage page blob.
          """
          return pulumi.get(self, "default_configuration_link")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VaultCertificateResponse(dict):
      """
      Describes a single certificate reference in a Key Vault, and where the certificate should reside on the VM.
      """
      def __init__(__self__, *,
                   certificate_store: Optional[str] = None,
                   certificate_url: Optional[str] = None):
          """
          Describes a single certificate reference in a Key Vault, and where the certificate should reside on the VM.
          :param str certificate_store: For Windows VMs, specifies the certificate store on the Virtual Machine to which the certificate should be added. The specified certificate store is implicitly in the LocalMachine account. <br><br>For Linux VMs, the certificate file is placed under the /var/lib/waagent directory, with the file name &lt;UppercaseThumbprint&gt;.crt for the X509 certificate file and &lt;UppercaseThumbprint&gt;.prv for private key. Both of these files are .pem formatted.
          :param str certificate_url: This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br>  "data":"<Base64-encoded-certificate>",<br>  "dataType":"pfx",<br>  "password":"<pfx-file-password>"<br>}
          """
          if certificate_store is not None:
              pulumi.set(__self__, "certificate_store", certificate_store)
          if certificate_url is not None:
              pulumi.set(__self__, "certificate_url", certificate_url)
  
      @property
      @pulumi.getter(name="certificateStore")
      def certificate_store(self) -> Optional[str]:
          """
          For Windows VMs, specifies the certificate store on the Virtual Machine to which the certificate should be added. The specified certificate store is implicitly in the LocalMachine account. <br><br>For Linux VMs, the certificate file is placed under the /var/lib/waagent directory, with the file name &lt;UppercaseThumbprint&gt;.crt for the X509 certificate file and &lt;UppercaseThumbprint&gt;.prv for private key. Both of these files are .pem formatted.
          """
          return pulumi.get(self, "certificate_store")
  
      @property
      @pulumi.getter(name="certificateUrl")
      def certificate_url(self) -> Optional[str]:
          """
          This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br>  "data":"<Base64-encoded-certificate>",<br>  "dataType":"pfx",<br>  "password":"<pfx-file-password>"<br>}
          """
          return pulumi.get(self, "certificate_url")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VaultSecretGroupResponse(dict):
      """
      Describes a set of certificates which are all in the same Key Vault.
      """
      def __init__(__self__, *,
                   source_vault: Optional['outputs.SubResourceResponse'] = None,
                   vault_certificates: Optional[Sequence['outputs.VaultCertificateResponse']] = None):
          """
          Describes a set of certificates which are all in the same Key Vault.
          :param 'SubResourceResponseArgs' source_vault: The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
          :param Sequence['VaultCertificateResponseArgs'] vault_certificates: The list of key vault references in SourceVault which contain certificates.
          """
          if source_vault is not None:
              pulumi.set(__self__, "source_vault", source_vault)
          if vault_certificates is not None:
              pulumi.set(__self__, "vault_certificates", vault_certificates)
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> Optional['outputs.SubResourceResponse']:
          """
          The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
          """
          return pulumi.get(self, "source_vault")
  
      @property
      @pulumi.getter(name="vaultCertificates")
      def vault_certificates(self) -> Optional[Sequence['outputs.VaultCertificateResponse']]:
          """
          The list of key vault references in SourceVault which contain certificates.
          """
          return pulumi.get(self, "vault_certificates")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualHardDiskResponse(dict):
      """
      Describes the uri of a disk.
      """
      def __init__(__self__, *,
                   uri: Optional[str] = None):
          """
          Describes the uri of a disk.
          :param str uri: Specifies the virtual hard disk's uri.
          """
          if uri is not None:
              pulumi.set(__self__, "uri", uri)
  
      @property
      @pulumi.getter
      def uri(self) -> Optional[str]:
          """
          Specifies the virtual hard disk's uri.
          """
          return pulumi.get(self, "uri")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineAgentInstanceViewResponse(dict):
      """
      The instance view of the VM Agent running on the virtual machine.
      """
      def __init__(__self__, *,
                   extension_handlers: Optional[Sequence['outputs.VirtualMachineExtensionHandlerInstanceViewResponse']] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None,
                   vm_agent_version: Optional[str] = None):
          """
          The instance view of the VM Agent running on the virtual machine.
          :param Sequence['VirtualMachineExtensionHandlerInstanceViewResponseArgs'] extension_handlers: The virtual machine extension handler instance view.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          :param str vm_agent_version: The VM Agent full version.
          """
          if extension_handlers is not None:
              pulumi.set(__self__, "extension_handlers", extension_handlers)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
          if vm_agent_version is not None:
              pulumi.set(__self__, "vm_agent_version", vm_agent_version)
  
      @property
      @pulumi.getter(name="extensionHandlers")
      def extension_handlers(self) -> Optional[Sequence['outputs.VirtualMachineExtensionHandlerInstanceViewResponse']]:
          """
          The virtual machine extension handler instance view.
          """
          return pulumi.get(self, "extension_handlers")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      @property
      @pulumi.getter(name="vmAgentVersion")
      def vm_agent_version(self) -> Optional[str]:
          """
          The VM Agent full version.
          """
          return pulumi.get(self, "vm_agent_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineExtensionHandlerInstanceViewResponse(dict):
      """
      The instance view of a virtual machine extension handler.
      """
      def __init__(__self__, *,
                   status: Optional['outputs.InstanceViewStatusResponse'] = None,
                   type: Optional[str] = None,
                   type_handler_version: Optional[str] = None):
          """
          The instance view of a virtual machine extension handler.
          :param 'InstanceViewStatusResponseArgs' status: The extension handler status.
          :param str type: Specifies the type of the extension; an example is "CustomScriptExtension".
          :param str type_handler_version: Specifies the version of the script handler.
          """
          if status is not None:
              pulumi.set(__self__, "status", status)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if type_handler_version is not None:
              pulumi.set(__self__, "type_handler_version", type_handler_version)
  
      @property
      @pulumi.getter
      def status(self) -> Optional['outputs.InstanceViewStatusResponse']:
          """
          The extension handler status.
          """
          return pulumi.get(self, "status")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          Specifies the type of the extension; an example is "CustomScriptExtension".
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[str]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineExtensionInstanceViewResponse(dict):
      """
      The instance view of a virtual machine extension.
      """
      def __init__(__self__, *,
                   name: Optional[str] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None,
                   substatuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None,
                   type: Optional[str] = None,
                   type_handler_version: Optional[str] = None):
          """
          The instance view of a virtual machine extension.
          :param str name: The virtual machine extension name.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          :param Sequence['InstanceViewStatusResponseArgs'] substatuses: The resource status information.
          :param str type: Specifies the type of the extension; an example is "CustomScriptExtension".
          :param str type_handler_version: Specifies the version of the script handler.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
          if substatuses is not None:
              pulumi.set(__self__, "substatuses", substatuses)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if type_handler_version is not None:
              pulumi.set(__self__, "type_handler_version", type_handler_version)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The virtual machine extension name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      @property
      @pulumi.getter
      def substatuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "substatuses")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          Specifies the type of the extension; an example is "CustomScriptExtension".
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[str]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineExtensionResponse(dict):
      """
      Describes a Virtual Machine Extension.
      """
      def __init__(__self__, *,
                   id: str,
                   location: str,
                   name: str,
                   provisioning_state: str,
                   type: str,
                   auto_upgrade_minor_version: Optional[bool] = None,
                   enable_automatic_upgrade: Optional[bool] = None,
                   force_update_tag: Optional[str] = None,
                   instance_view: Optional['outputs.VirtualMachineExtensionInstanceViewResponse'] = None,
                   protected_settings: Optional[Any] = None,
                   publisher: Optional[str] = None,
                   settings: Optional[Any] = None,
                   tags: Optional[Mapping[str, str]] = None,
                   type_handler_version: Optional[str] = None):
          """
          Describes a Virtual Machine Extension.
          :param str id: Resource Id
          :param str location: Resource location
          :param str name: Resource name
          :param str provisioning_state: The provisioning state, which only appears in the response.
          :param str type: Resource type
          :param bool auto_upgrade_minor_version: Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
          :param bool enable_automatic_upgrade: Indicates whether the extension should be automatically upgraded by the platform if there is a newer version of the extension available.
          :param str force_update_tag: How the extension handler should be forced to update even if the extension configuration has not changed.
          :param 'VirtualMachineExtensionInstanceViewResponseArgs' instance_view: The virtual machine extension instance view.
          :param Any protected_settings: The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
          :param str publisher: The name of the extension handler publisher.
          :param Any settings: Json formatted public settings for the extension.
          :param Mapping[str, str] tags: Resource tags
          :param str type_handler_version: Specifies the version of the script handler.
          """
          pulumi.set(__self__, "id", id)
          pulumi.set(__self__, "location", location)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "provisioning_state", provisioning_state)
          pulumi.set(__self__, "type", type)
          if auto_upgrade_minor_version is not None:
              pulumi.set(__self__, "auto_upgrade_minor_version", auto_upgrade_minor_version)
          if enable_automatic_upgrade is not None:
              pulumi.set(__self__, "enable_automatic_upgrade", enable_automatic_upgrade)
          if force_update_tag is not None:
              pulumi.set(__self__, "force_update_tag", force_update_tag)
          if instance_view is not None:
              pulumi.set(__self__, "instance_view", instance_view)
          if protected_settings is not None:
              pulumi.set(__self__, "protected_settings", protected_settings)
          if publisher is not None:
              pulumi.set(__self__, "publisher", publisher)
          if settings is not None:
              pulumi.set(__self__, "settings", settings)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
          if type_handler_version is not None:
              pulumi.set(__self__, "type_handler_version", type_handler_version)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter
      def location(self) -> str:
          """
          Resource location
          """
          return pulumi.get(self, "location")
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          Resource name
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> str:
          """
          The provisioning state, which only appears in the response.
          """
          return pulumi.get(self, "provisioning_state")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          Resource type
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="autoUpgradeMinorVersion")
      def auto_upgrade_minor_version(self) -> Optional[bool]:
          """
          Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
          """
          return pulumi.get(self, "auto_upgrade_minor_version")
  
      @property
      @pulumi.getter(name="enableAutomaticUpgrade")
      def enable_automatic_upgrade(self) -> Optional[bool]:
          """
          Indicates whether the extension should be automatically upgraded by the platform if there is a newer version of the extension available.
          """
          return pulumi.get(self, "enable_automatic_upgrade")
  
      @property
      @pulumi.getter(name="forceUpdateTag")
      def force_update_tag(self) -> Optional[str]:
          """
          How the extension handler should be forced to update even if the extension configuration has not changed.
          """
          return pulumi.get(self, "force_update_tag")
  
      @property
      @pulumi.getter(name="instanceView")
      def instance_view(self) -> Optional['outputs.VirtualMachineExtensionInstanceViewResponse']:
          """
          The virtual machine extension instance view.
          """
          return pulumi.get(self, "instance_view")
  
      @property
      @pulumi.getter(name="protectedSettings")
      def protected_settings(self) -> Optional[Any]:
          """
          The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
          """
          return pulumi.get(self, "protected_settings")
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[str]:
          """
          The name of the extension handler publisher.
          """
          return pulumi.get(self, "publisher")
  
      @property
      @pulumi.getter
      def settings(self) -> Optional[Any]:
          """
          Json formatted public settings for the extension.
          """
          return pulumi.get(self, "settings")
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[Mapping[str, str]]:
          """
          Resource tags
          """
          return pulumi.get(self, "tags")
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[str]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineHealthStatusResponse(dict):
      """
      The health status of the VM.
      """
      def __init__(__self__, *,
                   status: 'outputs.InstanceViewStatusResponse'):
          """
          The health status of the VM.
          :param 'InstanceViewStatusResponseArgs' status: The health status information for the VM.
          """
          pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter
      def status(self) -> 'outputs.InstanceViewStatusResponse':
          """
          The health status information for the VM.
          """
          return pulumi.get(self, "status")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineIdentityResponse(dict):
      """
      Identity for the virtual machine.
      """
      def __init__(__self__, *,
                   principal_id: str,
                   tenant_id: str,
                   type: Optional[str] = None,
                   user_assigned_identities: Optional[Mapping[str, 'outputs.VirtualMachineIdentityResponseUserAssignedIdentities']] = None):
          """
          Identity for the virtual machine.
          :param str principal_id: The principal id of virtual machine identity. This property will only be provided for a system assigned identity.
          :param str tenant_id: The tenant id associated with the virtual machine. This property will only be provided for a system assigned identity.
          :param str type: The type of identity used for the virtual machine. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
          :param Mapping[str, 'VirtualMachineIdentityResponseUserAssignedIdentitiesArgs'] user_assigned_identities: The list of user identities associated with the Virtual Machine. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "tenant_id", tenant_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if user_assigned_identities is not None:
              pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of virtual machine identity. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> str:
          """
          The tenant id associated with the virtual machine. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "tenant_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of identity used for the virtual machine. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.VirtualMachineIdentityResponseUserAssignedIdentities']]:
          """
          The list of user identities associated with the Virtual Machine. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          return pulumi.get(self, "user_assigned_identities")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineIdentityResponseUserAssignedIdentities(dict):
      def __init__(__self__, *,
                   client_id: str,
                   principal_id: str):
          """
          :param str client_id: The client id of user assigned identity.
          :param str principal_id: The principal id of user assigned identity.
          """
          pulumi.set(__self__, "client_id", client_id)
          pulumi.set(__self__, "principal_id", principal_id)
  
      @property
      @pulumi.getter(name="clientId")
      def client_id(self) -> str:
          """
          The client id of user assigned identity.
          """
          return pulumi.get(self, "client_id")
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of user assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineInstanceViewResponse(dict):
      """
      The instance view of a virtual machine.
      """
      def __init__(__self__, *,
                   assigned_host: str,
                   vm_health: 'outputs.VirtualMachineHealthStatusResponse',
                   boot_diagnostics: Optional['outputs.BootDiagnosticsInstanceViewResponse'] = None,
                   computer_name: Optional[str] = None,
                   disks: Optional[Sequence['outputs.DiskInstanceViewResponse']] = None,
                   extensions: Optional[Sequence['outputs.VirtualMachineExtensionInstanceViewResponse']] = None,
                   hyper_v_generation: Optional[str] = None,
                   maintenance_redeploy_status: Optional['outputs.MaintenanceRedeployStatusResponse'] = None,
                   os_name: Optional[str] = None,
                   os_version: Optional[str] = None,
                   patch_status: Optional['outputs.VirtualMachinePatchStatusResponse'] = None,
                   platform_fault_domain: Optional[int] = None,
                   platform_update_domain: Optional[int] = None,
                   rdp_thumb_print: Optional[str] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None,
                   vm_agent: Optional['outputs.VirtualMachineAgentInstanceViewResponse'] = None):
          """
          The instance view of a virtual machine.
          :param str assigned_host: Resource id of the dedicated host, on which the virtual machine is allocated through automatic placement, when the virtual machine is associated with a dedicated host group that has automatic placement enabled. <br><br>Minimum api-version: 2020-06-01.
          :param 'VirtualMachineHealthStatusResponseArgs' vm_health: The health status for the VM.
          :param 'BootDiagnosticsInstanceViewResponseArgs' boot_diagnostics: Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          :param str computer_name: The computer name assigned to the virtual machine.
          :param Sequence['DiskInstanceViewResponseArgs'] disks: The virtual machine disk information.
          :param Sequence['VirtualMachineExtensionInstanceViewResponseArgs'] extensions: The extensions information.
          :param str hyper_v_generation: Specifies the HyperVGeneration Type associated with a resource
          :param 'MaintenanceRedeployStatusResponseArgs' maintenance_redeploy_status: The Maintenance Operation status on the virtual machine.
          :param str os_name: The Operating System running on the virtual machine.
          :param str os_version: The version of Operating System running on the virtual machine.
          :param 'VirtualMachinePatchStatusResponseArgs' patch_status: [Preview Feature] The status of virtual machine patch operations.
          :param int platform_fault_domain: Specifies the fault domain of the virtual machine.
          :param int platform_update_domain: Specifies the update domain of the virtual machine.
          :param str rdp_thumb_print: The Remote desktop certificate thumbprint.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          :param 'VirtualMachineAgentInstanceViewResponseArgs' vm_agent: The VM Agent running on the virtual machine.
          """
          pulumi.set(__self__, "assigned_host", assigned_host)
          pulumi.set(__self__, "vm_health", vm_health)
          if boot_diagnostics is not None:
              pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
          if computer_name is not None:
              pulumi.set(__self__, "computer_name", computer_name)
          if disks is not None:
              pulumi.set(__self__, "disks", disks)
          if extensions is not None:
              pulumi.set(__self__, "extensions", extensions)
          if hyper_v_generation is not None:
              pulumi.set(__self__, "hyper_v_generation", hyper_v_generation)
          if maintenance_redeploy_status is not None:
              pulumi.set(__self__, "maintenance_redeploy_status", maintenance_redeploy_status)
          if os_name is not None:
              pulumi.set(__self__, "os_name", os_name)
          if os_version is not None:
              pulumi.set(__self__, "os_version", os_version)
          if patch_status is not None:
              pulumi.set(__self__, "patch_status", patch_status)
          if platform_fault_domain is not None:
              pulumi.set(__self__, "platform_fault_domain", platform_fault_domain)
          if platform_update_domain is not None:
              pulumi.set(__self__, "platform_update_domain", platform_update_domain)
          if rdp_thumb_print is not None:
              pulumi.set(__self__, "rdp_thumb_print", rdp_thumb_print)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
          if vm_agent is not None:
              pulumi.set(__self__, "vm_agent", vm_agent)
  
      @property
      @pulumi.getter(name="assignedHost")
      def assigned_host(self) -> str:
          """
          Resource id of the dedicated host, on which the virtual machine is allocated through automatic placement, when the virtual machine is associated with a dedicated host group that has automatic placement enabled. <br><br>Minimum api-version: 2020-06-01.
          """
          return pulumi.get(self, "assigned_host")
  
      @property
      @pulumi.getter(name="vmHealth")
      def vm_health(self) -> 'outputs.VirtualMachineHealthStatusResponse':
          """
          The health status for the VM.
          """
          return pulumi.get(self, "vm_health")
  
      @property
      @pulumi.getter(name="bootDiagnostics")
      def boot_diagnostics(self) -> Optional['outputs.BootDiagnosticsInstanceViewResponse']:
          """
          Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          """
          return pulumi.get(self, "boot_diagnostics")
  
      @property
      @pulumi.getter(name="computerName")
      def computer_name(self) -> Optional[str]:
          """
          The computer name assigned to the virtual machine.
          """
          return pulumi.get(self, "computer_name")
  
      @property
      @pulumi.getter
      def disks(self) -> Optional[Sequence['outputs.DiskInstanceViewResponse']]:
          """
          The virtual machine disk information.
          """
          return pulumi.get(self, "disks")
  
      @property
      @pulumi.getter
      def extensions(self) -> Optional[Sequence['outputs.VirtualMachineExtensionInstanceViewResponse']]:
          """
          The extensions information.
          """
          return pulumi.get(self, "extensions")
  
      @property
      @pulumi.getter(name="hyperVGeneration")
      def hyper_v_generation(self) -> Optional[str]:
          """
          Specifies the HyperVGeneration Type associated with a resource
          """
          return pulumi.get(self, "hyper_v_generation")
  
      @property
      @pulumi.getter(name="maintenanceRedeployStatus")
      def maintenance_redeploy_status(self) -> Optional['outputs.MaintenanceRedeployStatusResponse']:
          """
          The Maintenance Operation status on the virtual machine.
          """
          return pulumi.get(self, "maintenance_redeploy_status")
  
      @property
      @pulumi.getter(name="osName")
      def os_name(self) -> Optional[str]:
          """
          The Operating System running on the virtual machine.
          """
          return pulumi.get(self, "os_name")
  
      @property
      @pulumi.getter(name="osVersion")
      def os_version(self) -> Optional[str]:
          """
          The version of Operating System running on the virtual machine.
          """
          return pulumi.get(self, "os_version")
  
      @property
      @pulumi.getter(name="patchStatus")
      def patch_status(self) -> Optional['outputs.VirtualMachinePatchStatusResponse']:
          """
          [Preview Feature] The status of virtual machine patch operations.
          """
          return pulumi.get(self, "patch_status")
  
      @property
      @pulumi.getter(name="platformFaultDomain")
      def platform_fault_domain(self) -> Optional[int]:
          """
          Specifies the fault domain of the virtual machine.
          """
          return pulumi.get(self, "platform_fault_domain")
  
      @property
      @pulumi.getter(name="platformUpdateDomain")
      def platform_update_domain(self) -> Optional[int]:
          """
          Specifies the update domain of the virtual machine.
          """
          return pulumi.get(self, "platform_update_domain")
  
      @property
      @pulumi.getter(name="rdpThumbPrint")
      def rdp_thumb_print(self) -> Optional[str]:
          """
          The Remote desktop certificate thumbprint.
          """
          return pulumi.get(self, "rdp_thumb_print")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      @property
      @pulumi.getter(name="vmAgent")
      def vm_agent(self) -> Optional['outputs.VirtualMachineAgentInstanceViewResponse']:
          """
          The VM Agent running on the virtual machine.
          """
          return pulumi.get(self, "vm_agent")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachinePatchStatusResponse(dict):
      """
      The status of virtual machine patch operations.
      """
      def __init__(__self__, *,
                   configuration_statuses: Sequence['outputs.InstanceViewStatusResponse'],
                   available_patch_summary: Optional['outputs.AvailablePatchSummaryResponse'] = None,
                   last_patch_installation_summary: Optional['outputs.LastPatchInstallationSummaryResponse'] = None):
          """
          The status of virtual machine patch operations.
          :param Sequence['InstanceViewStatusResponseArgs'] configuration_statuses: The enablement status of the specified patchMode
          :param 'AvailablePatchSummaryResponseArgs' available_patch_summary: The available patch summary of the latest assessment operation for the virtual machine.
          :param 'LastPatchInstallationSummaryResponseArgs' last_patch_installation_summary: The installation summary of the latest installation operation for the virtual machine.
          """
          pulumi.set(__self__, "configuration_statuses", configuration_statuses)
          if available_patch_summary is not None:
              pulumi.set(__self__, "available_patch_summary", available_patch_summary)
          if last_patch_installation_summary is not None:
              pulumi.set(__self__, "last_patch_installation_summary", last_patch_installation_summary)
  
      @property
      @pulumi.getter(name="configurationStatuses")
      def configuration_statuses(self) -> Sequence['outputs.InstanceViewStatusResponse']:
          """
          The enablement status of the specified patchMode
          """
          return pulumi.get(self, "configuration_statuses")
  
      @property
      @pulumi.getter(name="availablePatchSummary")
      def available_patch_summary(self) -> Optional['outputs.AvailablePatchSummaryResponse']:
          """
          The available patch summary of the latest assessment operation for the virtual machine.
          """
          return pulumi.get(self, "available_patch_summary")
  
      @property
      @pulumi.getter(name="lastPatchInstallationSummary")
      def last_patch_installation_summary(self) -> Optional['outputs.LastPatchInstallationSummaryResponse']:
          """
          The installation summary of the latest installation operation for the virtual machine.
          """
          return pulumi.get(self, "last_patch_installation_summary")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineRunCommandInstanceViewResponse(dict):
      """
      The instance view of a virtual machine run command.
      """
      def __init__(__self__, *,
                   end_time: Optional[str] = None,
                   error: Optional[str] = None,
                   execution_message: Optional[str] = None,
                   execution_state: Optional[str] = None,
                   exit_code: Optional[int] = None,
                   output: Optional[str] = None,
                   start_time: Optional[str] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None):
          """
          The instance view of a virtual machine run command.
          :param str end_time: Script end time.
          :param str error: Script error stream.
          :param str execution_message: Communicate script configuration errors or execution messages.
          :param str execution_state: Script execution status.
          :param int exit_code: Exit code returned from script execution.
          :param str output: Script output stream.
          :param str start_time: Script start time.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          """
          if end_time is not None:
              pulumi.set(__self__, "end_time", end_time)
          if error is not None:
              pulumi.set(__self__, "error", error)
          if execution_message is not None:
              pulumi.set(__self__, "execution_message", execution_message)
          if execution_state is not None:
              pulumi.set(__self__, "execution_state", execution_state)
          if exit_code is not None:
              pulumi.set(__self__, "exit_code", exit_code)
          if output is not None:
              pulumi.set(__self__, "output", output)
          if start_time is not None:
              pulumi.set(__self__, "start_time", start_time)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
  
      @property
      @pulumi.getter(name="endTime")
      def end_time(self) -> Optional[str]:
          """
          Script end time.
          """
          return pulumi.get(self, "end_time")
  
      @property
      @pulumi.getter
      def error(self) -> Optional[str]:
          """
          Script error stream.
          """
          return pulumi.get(self, "error")
  
      @property
      @pulumi.getter(name="executionMessage")
      def execution_message(self) -> Optional[str]:
          """
          Communicate script configuration errors or execution messages.
          """
          return pulumi.get(self, "execution_message")
  
      @property
      @pulumi.getter(name="executionState")
      def execution_state(self) -> Optional[str]:
          """
          Script execution status.
          """
          return pulumi.get(self, "execution_state")
  
      @property
      @pulumi.getter(name="exitCode")
      def exit_code(self) -> Optional[int]:
          """
          Exit code returned from script execution.
          """
          return pulumi.get(self, "exit_code")
  
      @property
      @pulumi.getter
      def output(self) -> Optional[str]:
          """
          Script output stream.
          """
          return pulumi.get(self, "output")
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> Optional[str]:
          """
          Script start time.
          """
          return pulumi.get(self, "start_time")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineRunCommandScriptSourceResponse(dict):
      """
      Describes the script sources for run command.
      """
      def __init__(__self__, *,
                   command_id: Optional[str] = None,
                   script: Optional[str] = None,
                   script_uri: Optional[str] = None):
          """
          Describes the script sources for run command.
          :param str command_id: Specifies a commandId of predefined built-in script.
          :param str script: Specifies the script content to be executed on the VM.
          :param str script_uri: Specifies the script download location.
          """
          if command_id is not None:
              pulumi.set(__self__, "command_id", command_id)
          if script is not None:
              pulumi.set(__self__, "script", script)
          if script_uri is not None:
              pulumi.set(__self__, "script_uri", script_uri)
  
      @property
      @pulumi.getter(name="commandId")
      def command_id(self) -> Optional[str]:
          """
          Specifies a commandId of predefined built-in script.
          """
          return pulumi.get(self, "command_id")
  
      @property
      @pulumi.getter
      def script(self) -> Optional[str]:
          """
          Specifies the script content to be executed on the VM.
          """
          return pulumi.get(self, "script")
  
      @property
      @pulumi.getter(name="scriptUri")
      def script_uri(self) -> Optional[str]:
          """
          Specifies the script download location.
          """
          return pulumi.get(self, "script_uri")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetDataDiskResponse(dict):
      """
      Describes a virtual machine scale set data disk.
      """
      def __init__(__self__, *,
                   create_option: str,
                   lun: int,
                   caching: Optional[str] = None,
                   disk_iops_read_write: Optional[float] = None,
                   disk_m_bps_read_write: Optional[float] = None,
                   disk_size_gb: Optional[int] = None,
                   managed_disk: Optional['outputs.VirtualMachineScaleSetManagedDiskParametersResponse'] = None,
                   name: Optional[str] = None,
                   write_accelerator_enabled: Optional[bool] = None):
          """
          Describes a virtual machine scale set data disk.
          :param str create_option: The create option.
          :param int lun: Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          :param float disk_iops_read_write: Specifies the Read-Write IOPS for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
          :param float disk_m_bps_read_write: Specifies the bandwidth in MB per second for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
          :param int disk_size_gb: Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'VirtualMachineScaleSetManagedDiskParametersResponseArgs' managed_disk: The managed disk parameters.
          :param str name: The disk name.
          :param bool write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          pulumi.set(__self__, "create_option", create_option)
          pulumi.set(__self__, "lun", lun)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if disk_iops_read_write is not None:
              pulumi.set(__self__, "disk_iops_read_write", disk_iops_read_write)
          if disk_m_bps_read_write is not None:
              pulumi.set(__self__, "disk_m_bps_read_write", disk_m_bps_read_write)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if write_accelerator_enabled is not None:
              pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
  
      @property
      @pulumi.getter(name="createOption")
      def create_option(self) -> str:
          """
          The create option.
          """
          return pulumi.get(self, "create_option")
  
      @property
      @pulumi.getter
      def lun(self) -> int:
          """
          Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
          """
          return pulumi.get(self, "lun")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="diskIOPSReadWrite")
      def disk_iops_read_write(self) -> Optional[float]:
          """
          Specifies the Read-Write IOPS for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
          """
          return pulumi.get(self, "disk_iops_read_write")
  
      @property
      @pulumi.getter(name="diskMBpsReadWrite")
      def disk_m_bps_read_write(self) -> Optional[float]:
          """
          Specifies the bandwidth in MB per second for the managed disk. Should be used only when StorageAccountType is UltraSSD_LRS. If not specified, a default value would be assigned based on diskSizeGB.
          """
          return pulumi.get(self, "disk_m_bps_read_write")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.VirtualMachineScaleSetManagedDiskParametersResponse']:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[bool]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetExtensionProfileResponse(dict):
      """
      Describes a virtual machine scale set extension profile.
      """
      def __init__(__self__, *,
                   extensions: Optional[Sequence['outputs.VirtualMachineScaleSetExtensionResponse']] = None,
                   extensions_time_budget: Optional[str] = None):
          """
          Describes a virtual machine scale set extension profile.
          :param Sequence['VirtualMachineScaleSetExtensionResponseArgs'] extensions: The virtual machine scale set child extension resources.
          :param str extensions_time_budget: Specifies the time alloted for all extensions to start. The time duration should be between 15 minutes and 120 minutes (inclusive) and should be specified in ISO 8601 format. The default value is 90 minutes (PT1H30M). <br><br> Minimum api-version: 2020-06-01
          """
          if extensions is not None:
              pulumi.set(__self__, "extensions", extensions)
          if extensions_time_budget is not None:
              pulumi.set(__self__, "extensions_time_budget", extensions_time_budget)
  
      @property
      @pulumi.getter
      def extensions(self) -> Optional[Sequence['outputs.VirtualMachineScaleSetExtensionResponse']]:
          """
          The virtual machine scale set child extension resources.
          """
          return pulumi.get(self, "extensions")
  
      @property
      @pulumi.getter(name="extensionsTimeBudget")
      def extensions_time_budget(self) -> Optional[str]:
          """
          Specifies the time alloted for all extensions to start. The time duration should be between 15 minutes and 120 minutes (inclusive) and should be specified in ISO 8601 format. The default value is 90 minutes (PT1H30M). <br><br> Minimum api-version: 2020-06-01
          """
          return pulumi.get(self, "extensions_time_budget")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetExtensionResponse(dict):
      """
      Describes a Virtual Machine Scale Set Extension.
      """
      def __init__(__self__, *,
                   id: str,
                   provisioning_state: str,
                   type: str,
                   auto_upgrade_minor_version: Optional[bool] = None,
                   enable_automatic_upgrade: Optional[bool] = None,
                   force_update_tag: Optional[str] = None,
                   name: Optional[str] = None,
                   protected_settings: Optional[Any] = None,
                   provision_after_extensions: Optional[Sequence[str]] = None,
                   publisher: Optional[str] = None,
                   settings: Optional[Any] = None,
                   type_handler_version: Optional[str] = None):
          """
          Describes a Virtual Machine Scale Set Extension.
          :param str id: Resource Id
          :param str provisioning_state: The provisioning state, which only appears in the response.
          :param str type: Resource type
          :param bool auto_upgrade_minor_version: Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
          :param bool enable_automatic_upgrade: Indicates whether the extension should be automatically upgraded by the platform if there is a newer version of the extension available.
          :param str force_update_tag: If a value is provided and is different from the previous value, the extension handler will be forced to update even if the extension configuration has not changed.
          :param str name: The name of the extension.
          :param Any protected_settings: The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
          :param Sequence[str] provision_after_extensions: Collection of extension names after which this extension needs to be provisioned.
          :param str publisher: The name of the extension handler publisher.
          :param Any settings: Json formatted public settings for the extension.
          :param str type_handler_version: Specifies the version of the script handler.
          """
          pulumi.set(__self__, "id", id)
          pulumi.set(__self__, "provisioning_state", provisioning_state)
          pulumi.set(__self__, "type", type)
          if auto_upgrade_minor_version is not None:
              pulumi.set(__self__, "auto_upgrade_minor_version", auto_upgrade_minor_version)
          if enable_automatic_upgrade is not None:
              pulumi.set(__self__, "enable_automatic_upgrade", enable_automatic_upgrade)
          if force_update_tag is not None:
              pulumi.set(__self__, "force_update_tag", force_update_tag)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protected_settings is not None:
              pulumi.set(__self__, "protected_settings", protected_settings)
          if provision_after_extensions is not None:
              pulumi.set(__self__, "provision_after_extensions", provision_after_extensions)
          if publisher is not None:
              pulumi.set(__self__, "publisher", publisher)
          if settings is not None:
              pulumi.set(__self__, "settings", settings)
          if type_handler_version is not None:
              pulumi.set(__self__, "type_handler_version", type_handler_version)
  
      @property
      @pulumi.getter
      def id(self) -> str:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> str:
          """
          The provisioning state, which only appears in the response.
          """
          return pulumi.get(self, "provisioning_state")
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          Resource type
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="autoUpgradeMinorVersion")
      def auto_upgrade_minor_version(self) -> Optional[bool]:
          """
          Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
          """
          return pulumi.get(self, "auto_upgrade_minor_version")
  
      @property
      @pulumi.getter(name="enableAutomaticUpgrade")
      def enable_automatic_upgrade(self) -> Optional[bool]:
          """
          Indicates whether the extension should be automatically upgraded by the platform if there is a newer version of the extension available.
          """
          return pulumi.get(self, "enable_automatic_upgrade")
  
      @property
      @pulumi.getter(name="forceUpdateTag")
      def force_update_tag(self) -> Optional[str]:
          """
          If a value is provided and is different from the previous value, the extension handler will be forced to update even if the extension configuration has not changed.
          """
          return pulumi.get(self, "force_update_tag")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The name of the extension.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="protectedSettings")
      def protected_settings(self) -> Optional[Any]:
          """
          The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
          """
          return pulumi.get(self, "protected_settings")
  
      @property
      @pulumi.getter(name="provisionAfterExtensions")
      def provision_after_extensions(self) -> Optional[Sequence[str]]:
          """
          Collection of extension names after which this extension needs to be provisioned.
          """
          return pulumi.get(self, "provision_after_extensions")
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[str]:
          """
          The name of the extension handler publisher.
          """
          return pulumi.get(self, "publisher")
  
      @property
      @pulumi.getter
      def settings(self) -> Optional[Any]:
          """
          Json formatted public settings for the extension.
          """
          return pulumi.get(self, "settings")
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[str]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetIPConfigurationResponse(dict):
      """
      Describes a virtual machine scale set network profile's IP configuration.
      """
      def __init__(__self__, *,
                   name: str,
                   application_gateway_backend_address_pools: Optional[Sequence['outputs.SubResourceResponse']] = None,
                   application_security_groups: Optional[Sequence['outputs.SubResourceResponse']] = None,
                   id: Optional[str] = None,
                   load_balancer_backend_address_pools: Optional[Sequence['outputs.SubResourceResponse']] = None,
                   load_balancer_inbound_nat_pools: Optional[Sequence['outputs.SubResourceResponse']] = None,
                   primary: Optional[bool] = None,
                   private_ip_address_version: Optional[str] = None,
                   public_ip_address_configuration: Optional['outputs.VirtualMachineScaleSetPublicIPAddressConfigurationResponse'] = None,
                   subnet: Optional['outputs.ApiEntityReferenceResponse'] = None):
          """
          Describes a virtual machine scale set network profile's IP configuration.
          :param str name: The IP configuration name.
          :param Sequence['SubResourceResponseArgs'] application_gateway_backend_address_pools: Specifies an array of references to backend address pools of application gateways. A scale set can reference backend address pools of multiple application gateways. Multiple scale sets cannot use the same application gateway.
          :param Sequence['SubResourceResponseArgs'] application_security_groups: Specifies an array of references to application security group.
          :param str id: Resource Id
          :param Sequence['SubResourceResponseArgs'] load_balancer_backend_address_pools: Specifies an array of references to backend address pools of load balancers. A scale set can reference backend address pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
          :param Sequence['SubResourceResponseArgs'] load_balancer_inbound_nat_pools: Specifies an array of references to inbound Nat pools of the load balancers. A scale set can reference inbound nat pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
          :param bool primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          :param str private_ip_address_version: Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4.  Possible values are: 'IPv4' and 'IPv6'.
          :param 'VirtualMachineScaleSetPublicIPAddressConfigurationResponseArgs' public_ip_address_configuration: The publicIPAddressConfiguration.
          :param 'ApiEntityReferenceResponseArgs' subnet: Specifies the identifier of the subnet.
          """
          pulumi.set(__self__, "name", name)
          if application_gateway_backend_address_pools is not None:
              pulumi.set(__self__, "application_gateway_backend_address_pools", application_gateway_backend_address_pools)
          if application_security_groups is not None:
              pulumi.set(__self__, "application_security_groups", application_security_groups)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if load_balancer_backend_address_pools is not None:
              pulumi.set(__self__, "load_balancer_backend_address_pools", load_balancer_backend_address_pools)
          if load_balancer_inbound_nat_pools is not None:
              pulumi.set(__self__, "load_balancer_inbound_nat_pools", load_balancer_inbound_nat_pools)
          if primary is not None:
              pulumi.set(__self__, "primary", primary)
          if private_ip_address_version is not None:
              pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
          if public_ip_address_configuration is not None:
              pulumi.set(__self__, "public_ip_address_configuration", public_ip_address_configuration)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The IP configuration name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="applicationGatewayBackendAddressPools")
      def application_gateway_backend_address_pools(self) -> Optional[Sequence['outputs.SubResourceResponse']]:
          """
          Specifies an array of references to backend address pools of application gateways. A scale set can reference backend address pools of multiple application gateways. Multiple scale sets cannot use the same application gateway.
          """
          return pulumi.get(self, "application_gateway_backend_address_pools")
  
      @property
      @pulumi.getter(name="applicationSecurityGroups")
      def application_security_groups(self) -> Optional[Sequence['outputs.SubResourceResponse']]:
          """
          Specifies an array of references to application security group.
          """
          return pulumi.get(self, "application_security_groups")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter(name="loadBalancerBackendAddressPools")
      def load_balancer_backend_address_pools(self) -> Optional[Sequence['outputs.SubResourceResponse']]:
          """
          Specifies an array of references to backend address pools of load balancers. A scale set can reference backend address pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
          """
          return pulumi.get(self, "load_balancer_backend_address_pools")
  
      @property
      @pulumi.getter(name="loadBalancerInboundNatPools")
      def load_balancer_inbound_nat_pools(self) -> Optional[Sequence['outputs.SubResourceResponse']]:
          """
          Specifies an array of references to inbound Nat pools of the load balancers. A scale set can reference inbound nat pools of one public and one internal load balancer. Multiple scale sets cannot use the same basic sku load balancer.
          """
          return pulumi.get(self, "load_balancer_inbound_nat_pools")
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[bool]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      @property
      @pulumi.getter(name="privateIPAddressVersion")
      def private_ip_address_version(self) -> Optional[str]:
          """
          Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4.  Possible values are: 'IPv4' and 'IPv6'.
          """
          return pulumi.get(self, "private_ip_address_version")
  
      @property
      @pulumi.getter(name="publicIPAddressConfiguration")
      def public_ip_address_configuration(self) -> Optional['outputs.VirtualMachineScaleSetPublicIPAddressConfigurationResponse']:
          """
          The publicIPAddressConfiguration.
          """
          return pulumi.get(self, "public_ip_address_configuration")
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional['outputs.ApiEntityReferenceResponse']:
          """
          Specifies the identifier of the subnet.
          """
          return pulumi.get(self, "subnet")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetIdentityResponse(dict):
      """
      Identity for the virtual machine scale set.
      """
      def __init__(__self__, *,
                   principal_id: str,
                   tenant_id: str,
                   type: Optional[str] = None,
                   user_assigned_identities: Optional[Mapping[str, 'outputs.VirtualMachineScaleSetIdentityResponseUserAssignedIdentities']] = None):
          """
          Identity for the virtual machine scale set.
          :param str principal_id: The principal id of virtual machine scale set identity. This property will only be provided for a system assigned identity.
          :param str tenant_id: The tenant id associated with the virtual machine scale set. This property will only be provided for a system assigned identity.
          :param str type: The type of identity used for the virtual machine scale set. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine scale set.
          :param Mapping[str, 'VirtualMachineScaleSetIdentityResponseUserAssignedIdentitiesArgs'] user_assigned_identities: The list of user identities associated with the virtual machine scale set. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "tenant_id", tenant_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if user_assigned_identities is not None:
              pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of virtual machine scale set identity. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> str:
          """
          The tenant id associated with the virtual machine scale set. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "tenant_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of identity used for the virtual machine scale set. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine scale set.
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.VirtualMachineScaleSetIdentityResponseUserAssignedIdentities']]:
          """
          The list of user identities associated with the virtual machine scale set. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          return pulumi.get(self, "user_assigned_identities")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetIdentityResponseUserAssignedIdentities(dict):
      def __init__(__self__, *,
                   client_id: str,
                   principal_id: str):
          """
          :param str client_id: The client id of user assigned identity.
          :param str principal_id: The principal id of user assigned identity.
          """
          pulumi.set(__self__, "client_id", client_id)
          pulumi.set(__self__, "principal_id", principal_id)
  
      @property
      @pulumi.getter(name="clientId")
      def client_id(self) -> str:
          """
          The client id of user assigned identity.
          """
          return pulumi.get(self, "client_id")
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of user assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetIpTagResponse(dict):
      """
      Contains the IP tag associated with the public IP address.
      """
      def __init__(__self__, *,
                   ip_tag_type: Optional[str] = None,
                   tag: Optional[str] = None):
          """
          Contains the IP tag associated with the public IP address.
          :param str ip_tag_type: IP tag type. Example: FirstPartyUsage.
          :param str tag: IP tag associated with the public IP. Example: SQL, Storage etc.
          """
          if ip_tag_type is not None:
              pulumi.set(__self__, "ip_tag_type", ip_tag_type)
          if tag is not None:
              pulumi.set(__self__, "tag", tag)
  
      @property
      @pulumi.getter(name="ipTagType")
      def ip_tag_type(self) -> Optional[str]:
          """
          IP tag type. Example: FirstPartyUsage.
          """
          return pulumi.get(self, "ip_tag_type")
  
      @property
      @pulumi.getter
      def tag(self) -> Optional[str]:
          """
          IP tag associated with the public IP. Example: SQL, Storage etc.
          """
          return pulumi.get(self, "tag")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetManagedDiskParametersResponse(dict):
      """
      Describes the parameters of a ScaleSet managed disk.
      """
      def __init__(__self__, *,
                   disk_encryption_set: Optional['outputs.DiskEncryptionSetParametersResponse'] = None,
                   storage_account_type: Optional[str] = None):
          """
          Describes the parameters of a ScaleSet managed disk.
          :param 'DiskEncryptionSetParametersResponseArgs' disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
          :param str storage_account_type: Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          if disk_encryption_set is not None:
              pulumi.set(__self__, "disk_encryption_set", disk_encryption_set)
          if storage_account_type is not None:
              pulumi.set(__self__, "storage_account_type", storage_account_type)
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional['outputs.DiskEncryptionSetParametersResponse']:
          """
          Specifies the customer managed disk encryption set resource id for the managed disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[str]:
          """
          Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          return pulumi.get(self, "storage_account_type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetNetworkConfigurationDnsSettingsResponse(dict):
      """
      Describes a virtual machines scale sets network configuration's DNS settings.
      """
      def __init__(__self__, *,
                   dns_servers: Optional[Sequence[str]] = None):
          """
          Describes a virtual machines scale sets network configuration's DNS settings.
          :param Sequence[str] dns_servers: List of DNS servers IP addresses
          """
          if dns_servers is not None:
              pulumi.set(__self__, "dns_servers", dns_servers)
  
      @property
      @pulumi.getter(name="dnsServers")
      def dns_servers(self) -> Optional[Sequence[str]]:
          """
          List of DNS servers IP addresses
          """
          return pulumi.get(self, "dns_servers")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetNetworkConfigurationResponse(dict):
      """
      Describes a virtual machine scale set network profile's network configurations.
      """
      def __init__(__self__, *,
                   ip_configurations: Sequence['outputs.VirtualMachineScaleSetIPConfigurationResponse'],
                   name: str,
                   dns_settings: Optional['outputs.VirtualMachineScaleSetNetworkConfigurationDnsSettingsResponse'] = None,
                   enable_accelerated_networking: Optional[bool] = None,
                   enable_fpga: Optional[bool] = None,
                   enable_ip_forwarding: Optional[bool] = None,
                   id: Optional[str] = None,
                   network_security_group: Optional['outputs.SubResourceResponse'] = None,
                   primary: Optional[bool] = None):
          """
          Describes a virtual machine scale set network profile's network configurations.
          :param Sequence['VirtualMachineScaleSetIPConfigurationResponseArgs'] ip_configurations: Specifies the IP configurations of the network interface.
          :param str name: The network configuration name.
          :param 'VirtualMachineScaleSetNetworkConfigurationDnsSettingsResponseArgs' dns_settings: The dns settings to be applied on the network interfaces.
          :param bool enable_accelerated_networking: Specifies whether the network interface is accelerated networking-enabled.
          :param bool enable_fpga: Specifies whether the network interface is FPGA networking-enabled.
          :param bool enable_ip_forwarding: Whether IP forwarding enabled on this NIC.
          :param str id: Resource Id
          :param 'SubResourceResponseArgs' network_security_group: The network security group.
          :param bool primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          pulumi.set(__self__, "ip_configurations", ip_configurations)
          pulumi.set(__self__, "name", name)
          if dns_settings is not None:
              pulumi.set(__self__, "dns_settings", dns_settings)
          if enable_accelerated_networking is not None:
              pulumi.set(__self__, "enable_accelerated_networking", enable_accelerated_networking)
          if enable_fpga is not None:
              pulumi.set(__self__, "enable_fpga", enable_fpga)
          if enable_ip_forwarding is not None:
              pulumi.set(__self__, "enable_ip_forwarding", enable_ip_forwarding)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if network_security_group is not None:
              pulumi.set(__self__, "network_security_group", network_security_group)
          if primary is not None:
              pulumi.set(__self__, "primary", primary)
  
      @property
      @pulumi.getter(name="ipConfigurations")
      def ip_configurations(self) -> Sequence['outputs.VirtualMachineScaleSetIPConfigurationResponse']:
          """
          Specifies the IP configurations of the network interface.
          """
          return pulumi.get(self, "ip_configurations")
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The network configuration name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="dnsSettings")
      def dns_settings(self) -> Optional['outputs.VirtualMachineScaleSetNetworkConfigurationDnsSettingsResponse']:
          """
          The dns settings to be applied on the network interfaces.
          """
          return pulumi.get(self, "dns_settings")
  
      @property
      @pulumi.getter(name="enableAcceleratedNetworking")
      def enable_accelerated_networking(self) -> Optional[bool]:
          """
          Specifies whether the network interface is accelerated networking-enabled.
          """
          return pulumi.get(self, "enable_accelerated_networking")
  
      @property
      @pulumi.getter(name="enableFpga")
      def enable_fpga(self) -> Optional[bool]:
          """
          Specifies whether the network interface is FPGA networking-enabled.
          """
          return pulumi.get(self, "enable_fpga")
  
      @property
      @pulumi.getter(name="enableIPForwarding")
      def enable_ip_forwarding(self) -> Optional[bool]:
          """
          Whether IP forwarding enabled on this NIC.
          """
          return pulumi.get(self, "enable_ip_forwarding")
  
      @property
      @pulumi.getter
      def id(self) -> Optional[str]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @property
      @pulumi.getter(name="networkSecurityGroup")
      def network_security_group(self) -> Optional['outputs.SubResourceResponse']:
          """
          The network security group.
          """
          return pulumi.get(self, "network_security_group")
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[bool]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetNetworkProfileResponse(dict):
      """
      Describes a virtual machine scale set network profile.
      """
      def __init__(__self__, *,
                   health_probe: Optional['outputs.ApiEntityReferenceResponse'] = None,
                   network_interface_configurations: Optional[Sequence['outputs.VirtualMachineScaleSetNetworkConfigurationResponse']] = None):
          """
          Describes a virtual machine scale set network profile.
          :param 'ApiEntityReferenceResponseArgs' health_probe: A reference to a load balancer probe used to determine the health of an instance in the virtual machine scale set. The reference will be in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
          :param Sequence['VirtualMachineScaleSetNetworkConfigurationResponseArgs'] network_interface_configurations: The list of network configurations.
          """
          if health_probe is not None:
              pulumi.set(__self__, "health_probe", health_probe)
          if network_interface_configurations is not None:
              pulumi.set(__self__, "network_interface_configurations", network_interface_configurations)
  
      @property
      @pulumi.getter(name="healthProbe")
      def health_probe(self) -> Optional['outputs.ApiEntityReferenceResponse']:
          """
          A reference to a load balancer probe used to determine the health of an instance in the virtual machine scale set. The reference will be in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
          """
          return pulumi.get(self, "health_probe")
  
      @property
      @pulumi.getter(name="networkInterfaceConfigurations")
      def network_interface_configurations(self) -> Optional[Sequence['outputs.VirtualMachineScaleSetNetworkConfigurationResponse']]:
          """
          The list of network configurations.
          """
          return pulumi.get(self, "network_interface_configurations")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetOSDiskResponse(dict):
      """
      Describes a virtual machine scale set operating system disk.
      """
      def __init__(__self__, *,
                   create_option: str,
                   caching: Optional[str] = None,
                   diff_disk_settings: Optional['outputs.DiffDiskSettingsResponse'] = None,
                   disk_size_gb: Optional[int] = None,
                   image: Optional['outputs.VirtualHardDiskResponse'] = None,
                   managed_disk: Optional['outputs.VirtualMachineScaleSetManagedDiskParametersResponse'] = None,
                   name: Optional[str] = None,
                   os_type: Optional[str] = None,
                   vhd_containers: Optional[Sequence[str]] = None,
                   write_accelerator_enabled: Optional[bool] = None):
          """
          Describes a virtual machine scale set operating system disk.
          :param str create_option: Specifies how the virtual machines in the scale set should be created.<br><br> The only allowed value is: **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          :param str caching: Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          :param 'DiffDiskSettingsResponseArgs' diff_disk_settings: Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
          :param int disk_size_gb: Specifies the size of the operating system disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          :param 'VirtualHardDiskResponseArgs' image: Specifies information about the unmanaged user image to base the scale set on.
          :param 'VirtualMachineScaleSetManagedDiskParametersResponseArgs' managed_disk: The managed disk parameters.
          :param str name: The disk name.
          :param str os_type: This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          :param Sequence[str] vhd_containers: Specifies the container urls that are used to store operating system disks for the scale set.
          :param bool write_accelerator_enabled: Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          pulumi.set(__self__, "create_option", create_option)
          if caching is not None:
              pulumi.set(__self__, "caching", caching)
          if diff_disk_settings is not None:
              pulumi.set(__self__, "diff_disk_settings", diff_disk_settings)
          if disk_size_gb is not None:
              pulumi.set(__self__, "disk_size_gb", disk_size_gb)
          if image is not None:
              pulumi.set(__self__, "image", image)
          if managed_disk is not None:
              pulumi.set(__self__, "managed_disk", managed_disk)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if os_type is not None:
              pulumi.set(__self__, "os_type", os_type)
          if vhd_containers is not None:
              pulumi.set(__self__, "vhd_containers", vhd_containers)
          if write_accelerator_enabled is not None:
              pulumi.set(__self__, "write_accelerator_enabled", write_accelerator_enabled)
  
      @property
      @pulumi.getter(name="createOption")
      def create_option(self) -> str:
          """
          Specifies how the virtual machines in the scale set should be created.<br><br> The only allowed value is: **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you  also use the plan element previously described.
          """
          return pulumi.get(self, "create_option")
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[str]:
          """
          Specifies the caching requirements. <br><br> Possible values are: <br><br> **None** <br><br> **ReadOnly** <br><br> **ReadWrite** <br><br> Default: **None for Standard storage. ReadOnly for Premium storage**
          """
          return pulumi.get(self, "caching")
  
      @property
      @pulumi.getter(name="diffDiskSettings")
      def diff_disk_settings(self) -> Optional['outputs.DiffDiskSettingsResponse']:
          """
          Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
          """
          return pulumi.get(self, "diff_disk_settings")
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[int]:
          """
          Specifies the size of the operating system disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image. <br><br> This value cannot be larger than 1023 GB
          """
          return pulumi.get(self, "disk_size_gb")
  
      @property
      @pulumi.getter
      def image(self) -> Optional['outputs.VirtualHardDiskResponse']:
          """
          Specifies information about the unmanaged user image to base the scale set on.
          """
          return pulumi.get(self, "image")
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional['outputs.VirtualMachineScaleSetManagedDiskParametersResponse']:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> Optional[str]:
          """
          This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. <br><br> Possible values are: <br><br> **Windows** <br><br> **Linux**
          """
          return pulumi.get(self, "os_type")
  
      @property
      @pulumi.getter(name="vhdContainers")
      def vhd_containers(self) -> Optional[Sequence[str]]:
          """
          Specifies the container urls that are used to store operating system disks for the scale set.
          """
          return pulumi.get(self, "vhd_containers")
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[bool]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetOSProfileResponse(dict):
      """
      Describes a virtual machine scale set OS profile.
      """
      def __init__(__self__, *,
                   admin_password: Optional[str] = None,
                   admin_username: Optional[str] = None,
                   computer_name_prefix: Optional[str] = None,
                   custom_data: Optional[str] = None,
                   linux_configuration: Optional['outputs.LinuxConfigurationResponse'] = None,
                   secrets: Optional[Sequence['outputs.VaultSecretGroupResponse']] = None,
                   windows_configuration: Optional['outputs.WindowsConfigurationResponse'] = None):
          """
          Describes a virtual machine scale set OS profile.
          :param str admin_password: Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
          :param str admin_username: Specifies the name of the administrator account. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1  character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters  <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          :param str computer_name_prefix: Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long.
          :param str custom_data: Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          :param 'LinuxConfigurationResponseArgs' linux_configuration: Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          :param Sequence['VaultSecretGroupResponseArgs'] secrets: Specifies set of certificates that should be installed onto the virtual machines in the scale set.
          :param 'WindowsConfigurationResponseArgs' windows_configuration: Specifies Windows operating system settings on the virtual machine.
          """
          if admin_password is not None:
              pulumi.set(__self__, "admin_password", admin_password)
          if admin_username is not None:
              pulumi.set(__self__, "admin_username", admin_username)
          if computer_name_prefix is not None:
              pulumi.set(__self__, "computer_name_prefix", computer_name_prefix)
          if custom_data is not None:
              pulumi.set(__self__, "custom_data", custom_data)
          if linux_configuration is not None:
              pulumi.set(__self__, "linux_configuration", linux_configuration)
          if secrets is not None:
              pulumi.set(__self__, "secrets", secrets)
          if windows_configuration is not None:
              pulumi.set(__self__, "windows_configuration", windows_configuration)
  
      @property
      @pulumi.getter(name="adminPassword")
      def admin_password(self) -> Optional[str]:
          """
          Specifies the password of the administrator account. <br><br> **Minimum-length (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4 conditions below need to be fulfilled <br> Has lower characters <br>Has upper characters <br> Has a digit <br> Has a special character (Regex match [\W_]) <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!" <br><br> For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
          """
          return pulumi.get(self, "admin_password")
  
      @property
      @pulumi.getter(name="adminUsername")
      def admin_username(self) -> Optional[str]:
          """
          Specifies the name of the administrator account. <br><br> **Windows-only restriction:** Cannot end in "." <br><br> **Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5". <br><br> **Minimum-length (Linux):** 1  character <br><br> **Max-length (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters  <br><br><li> For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)<br><li> For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          """
          return pulumi.get(self, "admin_username")
  
      @property
      @pulumi.getter(name="computerNamePrefix")
      def computer_name_prefix(self) -> Optional[str]:
          """
          Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long.
          """
          return pulumi.get(self, "computer_name_prefix")
  
      @property
      @pulumi.getter(name="customData")
      def custom_data(self) -> Optional[str]:
          """
          Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes. <br><br> For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
          """
          return pulumi.get(self, "custom_data")
  
      @property
      @pulumi.getter(name="linuxConfiguration")
      def linux_configuration(self) -> Optional['outputs.LinuxConfigurationResponse']:
          """
          Specifies the Linux operating system settings on the virtual machine. <br><br>For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json) <br><br> For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          """
          return pulumi.get(self, "linux_configuration")
  
      @property
      @pulumi.getter
      def secrets(self) -> Optional[Sequence['outputs.VaultSecretGroupResponse']]:
          """
          Specifies set of certificates that should be installed onto the virtual machines in the scale set.
          """
          return pulumi.get(self, "secrets")
  
      @property
      @pulumi.getter(name="windowsConfiguration")
      def windows_configuration(self) -> Optional['outputs.WindowsConfigurationResponse']:
          """
          Specifies Windows operating system settings on the virtual machine.
          """
          return pulumi.get(self, "windows_configuration")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsResponse(dict):
      """
      Describes a virtual machines scale sets network configuration's DNS settings.
      """
      def __init__(__self__, *,
                   domain_name_label: str):
          """
          Describes a virtual machines scale sets network configuration's DNS settings.
          :param str domain_name_label: The Domain name label.The concatenation of the domain name label and vm index will be the domain name labels of the PublicIPAddress resources that will be created
          """
          pulumi.set(__self__, "domain_name_label", domain_name_label)
  
      @property
      @pulumi.getter(name="domainNameLabel")
      def domain_name_label(self) -> str:
          """
          The Domain name label.The concatenation of the domain name label and vm index will be the domain name labels of the PublicIPAddress resources that will be created
          """
          return pulumi.get(self, "domain_name_label")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetPublicIPAddressConfigurationResponse(dict):
      """
      Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration
      """
      def __init__(__self__, *,
                   name: str,
                   dns_settings: Optional['outputs.VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsResponse'] = None,
                   idle_timeout_in_minutes: Optional[int] = None,
                   ip_tags: Optional[Sequence['outputs.VirtualMachineScaleSetIpTagResponse']] = None,
                   public_ip_address_version: Optional[str] = None,
                   public_ip_prefix: Optional['outputs.SubResourceResponse'] = None):
          """
          Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration
          :param str name: The publicIP address configuration name.
          :param 'VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsResponseArgs' dns_settings: The dns settings to be applied on the publicIP addresses .
          :param int idle_timeout_in_minutes: The idle timeout of the public IP address.
          :param Sequence['VirtualMachineScaleSetIpTagResponseArgs'] ip_tags: The list of IP tags associated with the public IP address.
          :param str public_ip_address_version: Available from Api-Version 2019-07-01 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
          :param 'SubResourceResponseArgs' public_ip_prefix: The PublicIPPrefix from which to allocate publicIP addresses.
          """
          pulumi.set(__self__, "name", name)
          if dns_settings is not None:
              pulumi.set(__self__, "dns_settings", dns_settings)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if ip_tags is not None:
              pulumi.set(__self__, "ip_tags", ip_tags)
          if public_ip_address_version is not None:
              pulumi.set(__self__, "public_ip_address_version", public_ip_address_version)
          if public_ip_prefix is not None:
              pulumi.set(__self__, "public_ip_prefix", public_ip_prefix)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The publicIP address configuration name.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="dnsSettings")
      def dns_settings(self) -> Optional['outputs.VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsResponse']:
          """
          The dns settings to be applied on the publicIP addresses .
          """
          return pulumi.get(self, "dns_settings")
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[int]:
          """
          The idle timeout of the public IP address.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @property
      @pulumi.getter(name="ipTags")
      def ip_tags(self) -> Optional[Sequence['outputs.VirtualMachineScaleSetIpTagResponse']]:
          """
          The list of IP tags associated with the public IP address.
          """
          return pulumi.get(self, "ip_tags")
  
      @property
      @pulumi.getter(name="publicIPAddressVersion")
      def public_ip_address_version(self) -> Optional[str]:
          """
          Available from Api-Version 2019-07-01 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'.
          """
          return pulumi.get(self, "public_ip_address_version")
  
      @property
      @pulumi.getter(name="publicIPPrefix")
      def public_ip_prefix(self) -> Optional['outputs.SubResourceResponse']:
          """
          The PublicIPPrefix from which to allocate publicIP addresses.
          """
          return pulumi.get(self, "public_ip_prefix")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetStorageProfileResponse(dict):
      """
      Describes a virtual machine scale set storage profile.
      """
      def __init__(__self__, *,
                   data_disks: Optional[Sequence['outputs.VirtualMachineScaleSetDataDiskResponse']] = None,
                   image_reference: Optional['outputs.ImageReferenceResponse'] = None,
                   os_disk: Optional['outputs.VirtualMachineScaleSetOSDiskResponse'] = None):
          """
          Describes a virtual machine scale set storage profile.
          :param Sequence['VirtualMachineScaleSetDataDiskResponseArgs'] data_disks: Specifies the parameters that are used to add data disks to the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          :param 'ImageReferenceResponseArgs' image_reference: Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
          :param 'VirtualMachineScaleSetOSDiskResponseArgs' os_disk: Specifies information about the operating system disk used by the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          if data_disks is not None:
              pulumi.set(__self__, "data_disks", data_disks)
          if image_reference is not None:
              pulumi.set(__self__, "image_reference", image_reference)
          if os_disk is not None:
              pulumi.set(__self__, "os_disk", os_disk)
  
      @property
      @pulumi.getter(name="dataDisks")
      def data_disks(self) -> Optional[Sequence['outputs.VirtualMachineScaleSetDataDiskResponse']]:
          """
          Specifies the parameters that are used to add data disks to the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "data_disks")
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional['outputs.ImageReferenceResponse']:
          """
          Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
          """
          return pulumi.get(self, "image_reference")
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional['outputs.VirtualMachineScaleSetOSDiskResponse']:
          """
          Specifies information about the operating system disk used by the virtual machines in the scale set. <br><br> For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
          """
          return pulumi.get(self, "os_disk")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetVMInstanceViewResponse(dict):
      """
      The instance view of a virtual machine scale set VM.
      """
      def __init__(__self__, *,
                   assigned_host: str,
                   vm_health: 'outputs.VirtualMachineHealthStatusResponse',
                   boot_diagnostics: Optional['outputs.BootDiagnosticsInstanceViewResponse'] = None,
                   disks: Optional[Sequence['outputs.DiskInstanceViewResponse']] = None,
                   extensions: Optional[Sequence['outputs.VirtualMachineExtensionInstanceViewResponse']] = None,
                   maintenance_redeploy_status: Optional['outputs.MaintenanceRedeployStatusResponse'] = None,
                   placement_group_id: Optional[str] = None,
                   platform_fault_domain: Optional[int] = None,
                   platform_update_domain: Optional[int] = None,
                   rdp_thumb_print: Optional[str] = None,
                   statuses: Optional[Sequence['outputs.InstanceViewStatusResponse']] = None,
                   vm_agent: Optional['outputs.VirtualMachineAgentInstanceViewResponse'] = None):
          """
          The instance view of a virtual machine scale set VM.
          :param str assigned_host: Resource id of the dedicated host, on which the virtual machine is allocated through automatic placement, when the virtual machine is associated with a dedicated host group that has automatic placement enabled. <br><br>Minimum api-version: 2020-06-01.
          :param 'VirtualMachineHealthStatusResponseArgs' vm_health: The health status for the VM.
          :param 'BootDiagnosticsInstanceViewResponseArgs' boot_diagnostics: Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          :param Sequence['DiskInstanceViewResponseArgs'] disks: The disks information.
          :param Sequence['VirtualMachineExtensionInstanceViewResponseArgs'] extensions: The extensions information.
          :param 'MaintenanceRedeployStatusResponseArgs' maintenance_redeploy_status: The Maintenance Operation status on the virtual machine.
          :param str placement_group_id: The placement group in which the VM is running. If the VM is deallocated it will not have a placementGroupId.
          :param int platform_fault_domain: The Fault Domain count.
          :param int platform_update_domain: The Update Domain count.
          :param str rdp_thumb_print: The Remote desktop certificate thumbprint.
          :param Sequence['InstanceViewStatusResponseArgs'] statuses: The resource status information.
          :param 'VirtualMachineAgentInstanceViewResponseArgs' vm_agent: The VM Agent running on the virtual machine.
          """
          pulumi.set(__self__, "assigned_host", assigned_host)
          pulumi.set(__self__, "vm_health", vm_health)
          if boot_diagnostics is not None:
              pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
          if disks is not None:
              pulumi.set(__self__, "disks", disks)
          if extensions is not None:
              pulumi.set(__self__, "extensions", extensions)
          if maintenance_redeploy_status is not None:
              pulumi.set(__self__, "maintenance_redeploy_status", maintenance_redeploy_status)
          if placement_group_id is not None:
              pulumi.set(__self__, "placement_group_id", placement_group_id)
          if platform_fault_domain is not None:
              pulumi.set(__self__, "platform_fault_domain", platform_fault_domain)
          if platform_update_domain is not None:
              pulumi.set(__self__, "platform_update_domain", platform_update_domain)
          if rdp_thumb_print is not None:
              pulumi.set(__self__, "rdp_thumb_print", rdp_thumb_print)
          if statuses is not None:
              pulumi.set(__self__, "statuses", statuses)
          if vm_agent is not None:
              pulumi.set(__self__, "vm_agent", vm_agent)
  
      @property
      @pulumi.getter(name="assignedHost")
      def assigned_host(self) -> str:
          """
          Resource id of the dedicated host, on which the virtual machine is allocated through automatic placement, when the virtual machine is associated with a dedicated host group that has automatic placement enabled. <br><br>Minimum api-version: 2020-06-01.
          """
          return pulumi.get(self, "assigned_host")
  
      @property
      @pulumi.getter(name="vmHealth")
      def vm_health(self) -> 'outputs.VirtualMachineHealthStatusResponse':
          """
          The health status for the VM.
          """
          return pulumi.get(self, "vm_health")
  
      @property
      @pulumi.getter(name="bootDiagnostics")
      def boot_diagnostics(self) -> Optional['outputs.BootDiagnosticsInstanceViewResponse']:
          """
          Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. <br><br> You can easily view the output of your console log. <br><br> Azure also enables you to see a screenshot of the VM from the hypervisor.
          """
          return pulumi.get(self, "boot_diagnostics")
  
      @property
      @pulumi.getter
      def disks(self) -> Optional[Sequence['outputs.DiskInstanceViewResponse']]:
          """
          The disks information.
          """
          return pulumi.get(self, "disks")
  
      @property
      @pulumi.getter
      def extensions(self) -> Optional[Sequence['outputs.VirtualMachineExtensionInstanceViewResponse']]:
          """
          The extensions information.
          """
          return pulumi.get(self, "extensions")
  
      @property
      @pulumi.getter(name="maintenanceRedeployStatus")
      def maintenance_redeploy_status(self) -> Optional['outputs.MaintenanceRedeployStatusResponse']:
          """
          The Maintenance Operation status on the virtual machine.
          """
          return pulumi.get(self, "maintenance_redeploy_status")
  
      @property
      @pulumi.getter(name="placementGroupId")
      def placement_group_id(self) -> Optional[str]:
          """
          The placement group in which the VM is running. If the VM is deallocated it will not have a placementGroupId.
          """
          return pulumi.get(self, "placement_group_id")
  
      @property
      @pulumi.getter(name="platformFaultDomain")
      def platform_fault_domain(self) -> Optional[int]:
          """
          The Fault Domain count.
          """
          return pulumi.get(self, "platform_fault_domain")
  
      @property
      @pulumi.getter(name="platformUpdateDomain")
      def platform_update_domain(self) -> Optional[int]:
          """
          The Update Domain count.
          """
          return pulumi.get(self, "platform_update_domain")
  
      @property
      @pulumi.getter(name="rdpThumbPrint")
      def rdp_thumb_print(self) -> Optional[str]:
          """
          The Remote desktop certificate thumbprint.
          """
          return pulumi.get(self, "rdp_thumb_print")
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[Sequence['outputs.InstanceViewStatusResponse']]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      @property
      @pulumi.getter(name="vmAgent")
      def vm_agent(self) -> Optional['outputs.VirtualMachineAgentInstanceViewResponse']:
          """
          The VM Agent running on the virtual machine.
          """
          return pulumi.get(self, "vm_agent")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetVMNetworkProfileConfigurationResponse(dict):
      """
      Describes a virtual machine scale set VM network profile.
      """
      def __init__(__self__, *,
                   network_interface_configurations: Optional[Sequence['outputs.VirtualMachineScaleSetNetworkConfigurationResponse']] = None):
          """
          Describes a virtual machine scale set VM network profile.
          :param Sequence['VirtualMachineScaleSetNetworkConfigurationResponseArgs'] network_interface_configurations: The list of network configurations.
          """
          if network_interface_configurations is not None:
              pulumi.set(__self__, "network_interface_configurations", network_interface_configurations)
  
      @property
      @pulumi.getter(name="networkInterfaceConfigurations")
      def network_interface_configurations(self) -> Optional[Sequence['outputs.VirtualMachineScaleSetNetworkConfigurationResponse']]:
          """
          The list of network configurations.
          """
          return pulumi.get(self, "network_interface_configurations")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetVMProfileResponse(dict):
      """
      Describes a virtual machine scale set virtual machine profile.
      """
      def __init__(__self__, *,
                   billing_profile: Optional['outputs.BillingProfileResponse'] = None,
                   diagnostics_profile: Optional['outputs.DiagnosticsProfileResponse'] = None,
                   eviction_policy: Optional[str] = None,
                   extension_profile: Optional['outputs.VirtualMachineScaleSetExtensionProfileResponse'] = None,
                   license_type: Optional[str] = None,
                   network_profile: Optional['outputs.VirtualMachineScaleSetNetworkProfileResponse'] = None,
                   os_profile: Optional['outputs.VirtualMachineScaleSetOSProfileResponse'] = None,
                   priority: Optional[str] = None,
                   scheduled_events_profile: Optional['outputs.ScheduledEventsProfileResponse'] = None,
                   security_profile: Optional['outputs.SecurityProfileResponse'] = None,
                   storage_profile: Optional['outputs.VirtualMachineScaleSetStorageProfileResponse'] = None):
          """
          Describes a virtual machine scale set virtual machine profile.
          :param 'BillingProfileResponseArgs' billing_profile: Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
          :param 'DiagnosticsProfileResponseArgs' diagnostics_profile: Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          :param str eviction_policy: Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2019-03-01. <br><br>For Azure Spot scale sets, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2017-10-30-preview.
          :param 'VirtualMachineScaleSetExtensionProfileResponseArgs' extension_profile: Specifies a collection of settings for extensions installed on virtual machines in the scale set.
          :param str license_type: Specifies that the image or disk that is being used was licensed on-premises. <br><br> Possible values for Windows Server operating system are: <br><br> Windows_Client <br><br> Windows_Server <br><br> Possible values for Linux Server operating system are: <br><br> RHEL_BYOS (for RHEL) <br><br> SLES_BYOS (for SUSE) <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/windows/hybrid-use-benefit-licensing) <br><br> [Azure Hybrid Use Benefit for Linux Server](https://docs.microsoft.com/azure/virtual-machines/linux/azure-hybrid-benefit-linux) <br><br> Minimum api-version: 2015-06-15
          :param 'VirtualMachineScaleSetNetworkProfileResponseArgs' network_profile: Specifies properties of the network interfaces of the virtual machines in the scale set.
          :param 'VirtualMachineScaleSetOSProfileResponseArgs' os_profile: Specifies the operating system settings for the virtual machines in the scale set.
          :param str priority: Specifies the priority for the virtual machines in the scale set. <br><br>Minimum api-version: 2017-10-30-preview
          :param 'ScheduledEventsProfileResponseArgs' scheduled_events_profile: Specifies Scheduled Event related configurations.
          :param 'SecurityProfileResponseArgs' security_profile: Specifies the Security related profile settings for the virtual machines in the scale set.
          :param 'VirtualMachineScaleSetStorageProfileResponseArgs' storage_profile: Specifies the storage settings for the virtual machine disks.
          """
          if billing_profile is not None:
              pulumi.set(__self__, "billing_profile", billing_profile)
          if diagnostics_profile is not None:
              pulumi.set(__self__, "diagnostics_profile", diagnostics_profile)
          if eviction_policy is not None:
              pulumi.set(__self__, "eviction_policy", eviction_policy)
          if extension_profile is not None:
              pulumi.set(__self__, "extension_profile", extension_profile)
          if license_type is not None:
              pulumi.set(__self__, "license_type", license_type)
          if network_profile is not None:
              pulumi.set(__self__, "network_profile", network_profile)
          if os_profile is not None:
              pulumi.set(__self__, "os_profile", os_profile)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if scheduled_events_profile is not None:
              pulumi.set(__self__, "scheduled_events_profile", scheduled_events_profile)
          if security_profile is not None:
              pulumi.set(__self__, "security_profile", security_profile)
          if storage_profile is not None:
              pulumi.set(__self__, "storage_profile", storage_profile)
  
      @property
      @pulumi.getter(name="billingProfile")
      def billing_profile(self) -> Optional['outputs.BillingProfileResponse']:
          """
          Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
          """
          return pulumi.get(self, "billing_profile")
  
      @property
      @pulumi.getter(name="diagnosticsProfile")
      def diagnostics_profile(self) -> Optional['outputs.DiagnosticsProfileResponse']:
          """
          Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          """
          return pulumi.get(self, "diagnostics_profile")
  
      @property
      @pulumi.getter(name="evictionPolicy")
      def eviction_policy(self) -> Optional[str]:
          """
          Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2019-03-01. <br><br>For Azure Spot scale sets, both 'Deallocate' and 'Delete' are supported and the minimum api-version is 2017-10-30-preview.
          """
          return pulumi.get(self, "eviction_policy")
  
      @property
      @pulumi.getter(name="extensionProfile")
      def extension_profile(self) -> Optional['outputs.VirtualMachineScaleSetExtensionProfileResponse']:
          """
          Specifies a collection of settings for extensions installed on virtual machines in the scale set.
          """
          return pulumi.get(self, "extension_profile")
  
      @property
      @pulumi.getter(name="licenseType")
      def license_type(self) -> Optional[str]:
          """
          Specifies that the image or disk that is being used was licensed on-premises. <br><br> Possible values for Windows Server operating system are: <br><br> Windows_Client <br><br> Windows_Server <br><br> Possible values for Linux Server operating system are: <br><br> RHEL_BYOS (for RHEL) <br><br> SLES_BYOS (for SUSE) <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/windows/hybrid-use-benefit-licensing) <br><br> [Azure Hybrid Use Benefit for Linux Server](https://docs.microsoft.com/azure/virtual-machines/linux/azure-hybrid-benefit-linux) <br><br> Minimum api-version: 2015-06-15
          """
          return pulumi.get(self, "license_type")
  
      @property
      @pulumi.getter(name="networkProfile")
      def network_profile(self) -> Optional['outputs.VirtualMachineScaleSetNetworkProfileResponse']:
          """
          Specifies properties of the network interfaces of the virtual machines in the scale set.
          """
          return pulumi.get(self, "network_profile")
  
      @property
      @pulumi.getter(name="osProfile")
      def os_profile(self) -> Optional['outputs.VirtualMachineScaleSetOSProfileResponse']:
          """
          Specifies the operating system settings for the virtual machines in the scale set.
          """
          return pulumi.get(self, "os_profile")
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[str]:
          """
          Specifies the priority for the virtual machines in the scale set. <br><br>Minimum api-version: 2017-10-30-preview
          """
          return pulumi.get(self, "priority")
  
      @property
      @pulumi.getter(name="scheduledEventsProfile")
      def scheduled_events_profile(self) -> Optional['outputs.ScheduledEventsProfileResponse']:
          """
          Specifies Scheduled Event related configurations.
          """
          return pulumi.get(self, "scheduled_events_profile")
  
      @property
      @pulumi.getter(name="securityProfile")
      def security_profile(self) -> Optional['outputs.SecurityProfileResponse']:
          """
          Specifies the Security related profile settings for the virtual machines in the scale set.
          """
          return pulumi.get(self, "security_profile")
  
      @property
      @pulumi.getter(name="storageProfile")
      def storage_profile(self) -> Optional['outputs.VirtualMachineScaleSetStorageProfileResponse']:
          """
          Specifies the storage settings for the virtual machine disks.
          """
          return pulumi.get(self, "storage_profile")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class VirtualMachineScaleSetVMProtectionPolicyResponse(dict):
      """
      The protection policy of a virtual machine scale set VM.
      """
      def __init__(__self__, *,
                   protect_from_scale_in: Optional[bool] = None,
                   protect_from_scale_set_actions: Optional[bool] = None):
          """
          The protection policy of a virtual machine scale set VM.
          :param bool protect_from_scale_in: Indicates that the virtual machine scale set VM shouldn't be considered for deletion during a scale-in operation.
          :param bool protect_from_scale_set_actions: Indicates that model updates or actions (including scale-in) initiated on the virtual machine scale set should not be applied to the virtual machine scale set VM.
          """
          if protect_from_scale_in is not None:
              pulumi.set(__self__, "protect_from_scale_in", protect_from_scale_in)
          if protect_from_scale_set_actions is not None:
              pulumi.set(__self__, "protect_from_scale_set_actions", protect_from_scale_set_actions)
  
      @property
      @pulumi.getter(name="protectFromScaleIn")
      def protect_from_scale_in(self) -> Optional[bool]:
          """
          Indicates that the virtual machine scale set VM shouldn't be considered for deletion during a scale-in operation.
          """
          return pulumi.get(self, "protect_from_scale_in")
  
      @property
      @pulumi.getter(name="protectFromScaleSetActions")
      def protect_from_scale_set_actions(self) -> Optional[bool]:
          """
          Indicates that model updates or actions (including scale-in) initiated on the virtual machine scale set should not be applied to the virtual machine scale set VM.
          """
          return pulumi.get(self, "protect_from_scale_set_actions")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class WinRMConfigurationResponse(dict):
      """
      Describes Windows Remote Management configuration of the VM
      """
      def __init__(__self__, *,
                   listeners: Optional[Sequence['outputs.WinRMListenerResponse']] = None):
          """
          Describes Windows Remote Management configuration of the VM
          :param Sequence['WinRMListenerResponseArgs'] listeners: The list of Windows Remote Management listeners
          """
          if listeners is not None:
              pulumi.set(__self__, "listeners", listeners)
  
      @property
      @pulumi.getter
      def listeners(self) -> Optional[Sequence['outputs.WinRMListenerResponse']]:
          """
          The list of Windows Remote Management listeners
          """
          return pulumi.get(self, "listeners")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class WinRMListenerResponse(dict):
      """
      Describes Protocol and thumbprint of Windows Remote Management listener
      """
      def __init__(__self__, *,
                   certificate_url: Optional[str] = None,
                   protocol: Optional[str] = None):
          """
          Describes Protocol and thumbprint of Windows Remote Management listener
          :param str certificate_url: This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br>  "data":"<Base64-encoded-certificate>",<br>  "dataType":"pfx",<br>  "password":"<pfx-file-password>"<br>}
          :param str protocol: Specifies the protocol of WinRM listener. <br><br> Possible values are: <br>**http** <br><br> **https**
          """
          if certificate_url is not None:
              pulumi.set(__self__, "certificate_url", certificate_url)
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
  
      @property
      @pulumi.getter(name="certificateUrl")
      def certificate_url(self) -> Optional[str]:
          """
          This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8: <br><br> {<br>  "data":"<Base64-encoded-certificate>",<br>  "dataType":"pfx",<br>  "password":"<pfx-file-password>"<br>}
          """
          return pulumi.get(self, "certificate_url")
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[str]:
          """
          Specifies the protocol of WinRM listener. <br><br> Possible values are: <br>**http** <br><br> **https**
          """
          return pulumi.get(self, "protocol")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class WindowsConfigurationResponse(dict):
      """
      Specifies Windows operating system settings on the virtual machine.
      """
      def __init__(__self__, *,
                   additional_unattend_content: Optional[Sequence['outputs.AdditionalUnattendContentResponse']] = None,
                   enable_automatic_updates: Optional[bool] = None,
                   patch_settings: Optional['outputs.PatchSettingsResponse'] = None,
                   provision_vm_agent: Optional[bool] = None,
                   time_zone: Optional[str] = None,
                   win_rm: Optional['outputs.WinRMConfigurationResponse'] = None):
          """
          Specifies Windows operating system settings on the virtual machine.
          :param Sequence['AdditionalUnattendContentResponseArgs'] additional_unattend_content: Specifies additional base-64 encoded XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup.
          :param bool enable_automatic_updates: Indicates whether Automatic Updates is enabled for the Windows virtual machine. Default value is true. <br><br> For virtual machine scale sets, this property can be updated and updates will take effect on OS reprovisioning.
          :param 'PatchSettingsResponseArgs' patch_settings: [Preview Feature] Specifies settings related to VM Guest Patching on Windows.
          :param bool provision_vm_agent: Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true.  This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
          :param str time_zone: Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time". <br><br> Possible values can be [TimeZoneInfo.Id](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.id?#System_TimeZoneInfo_Id) value from time zones returned by [TimeZoneInfo.GetSystemTimeZones](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.getsystemtimezones).
          :param 'WinRMConfigurationResponseArgs' win_rm: Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
          """
          if additional_unattend_content is not None:
              pulumi.set(__self__, "additional_unattend_content", additional_unattend_content)
          if enable_automatic_updates is not None:
              pulumi.set(__self__, "enable_automatic_updates", enable_automatic_updates)
          if patch_settings is not None:
              pulumi.set(__self__, "patch_settings", patch_settings)
          if provision_vm_agent is not None:
              pulumi.set(__self__, "provision_vm_agent", provision_vm_agent)
          if time_zone is not None:
              pulumi.set(__self__, "time_zone", time_zone)
          if win_rm is not None:
              pulumi.set(__self__, "win_rm", win_rm)
  
      @property
      @pulumi.getter(name="additionalUnattendContent")
      def additional_unattend_content(self) -> Optional[Sequence['outputs.AdditionalUnattendContentResponse']]:
          """
          Specifies additional base-64 encoded XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup.
          """
          return pulumi.get(self, "additional_unattend_content")
  
      @property
      @pulumi.getter(name="enableAutomaticUpdates")
      def enable_automatic_updates(self) -> Optional[bool]:
          """
          Indicates whether Automatic Updates is enabled for the Windows virtual machine. Default value is true. <br><br> For virtual machine scale sets, this property can be updated and updates will take effect on OS reprovisioning.
          """
          return pulumi.get(self, "enable_automatic_updates")
  
      @property
      @pulumi.getter(name="patchSettings")
      def patch_settings(self) -> Optional['outputs.PatchSettingsResponse']:
          """
          [Preview Feature] Specifies settings related to VM Guest Patching on Windows.
          """
          return pulumi.get(self, "patch_settings")
  
      @property
      @pulumi.getter(name="provisionVMAgent")
      def provision_vm_agent(self) -> Optional[bool]:
          """
          Indicates whether virtual machine agent should be provisioned on the virtual machine. <br><br> When this property is not specified in the request body, default behavior is to set it to true.  This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
          """
          return pulumi.get(self, "provision_vm_agent")
  
      @property
      @pulumi.getter(name="timeZone")
      def time_zone(self) -> Optional[str]:
          """
          Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time". <br><br> Possible values can be [TimeZoneInfo.Id](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.id?#System_TimeZoneInfo_Id) value from time zones returned by [TimeZoneInfo.GetSystemTimeZones](https://docs.microsoft.com/en-us/dotnet/api/system.timezoneinfo.getsystemtimezones).
          """
          return pulumi.get(self, "time_zone")
  
      @property
      @pulumi.getter(name="winRM")
      def win_rm(self) -> Optional['outputs.WinRMConfigurationResponse']:
          """
          Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
          """
          return pulumi.get(self, "win_rm")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  