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 ._enums import *
  
  __all__ = [
      'AdditionalCapabilitiesArgs',
      'AdditionalUnattendContentArgs',
      'ApiEntityReferenceArgs',
      'AutomaticOSUpgradePolicyArgs',
      'AutomaticRepairsPolicyArgs',
      'BillingProfileArgs',
      'BootDiagnosticsArgs',
      'CreationDataArgs',
      'DataDiskArgs',
      'DiagnosticsProfileArgs',
      'DiffDiskSettingsArgs',
      'DisallowedArgs',
      'DiskEncryptionSetParametersArgs',
      'DiskEncryptionSettingsArgs',
      'DiskSkuArgs',
      'EncryptionArgs',
      'EncryptionSetIdentityArgs',
      'EncryptionSettingsCollectionArgs',
      'EncryptionSettingsElementArgs',
      'GalleryApplicationVersionPublishingProfileArgs',
      'GalleryArtifactVersionSourceArgs',
      'GalleryDataDiskImageArgs',
      'GalleryImageIdentifierArgs',
      'GalleryImageVersionPublishingProfileArgs',
      'GalleryImageVersionStorageProfileArgs',
      'GalleryOSDiskImageArgs',
      'HardwareProfileArgs',
      'ImageDataDiskArgs',
      'ImageDiskReferenceArgs',
      'ImageOSDiskArgs',
      'ImagePurchasePlanArgs',
      'ImageReferenceArgs',
      'ImageStorageProfileArgs',
      'InstanceViewStatusArgs',
      'KeyVaultAndKeyReferenceArgs',
      'KeyVaultAndSecretReferenceArgs',
      'KeyVaultKeyReferenceArgs',
      'KeyVaultSecretReferenceArgs',
      'LinuxConfigurationArgs',
      'ManagedDiskParametersArgs',
      'NetworkInterfaceReferenceArgs',
      'NetworkProfileArgs',
      'OSDiskArgs',
      'OSProfileArgs',
      'PlanArgs',
      'RecommendedMachineConfigurationArgs',
      'ResourceRangeArgs',
      'RollingUpgradePolicyArgs',
      'ScaleInPolicyArgs',
      'ScheduledEventsProfileArgs',
      'SkuArgs',
      'SnapshotSkuArgs',
      'SourceVaultArgs',
      'SshConfigurationArgs',
      'SshPublicKeyArgs',
      'StorageProfileArgs',
      'SubResourceArgs',
      'TargetRegionArgs',
      'TerminateNotificationProfileArgs',
      'UpgradePolicyArgs',
      'UserArtifactManageArgs',
      'UserArtifactSourceArgs',
      'VaultCertificateArgs',
      'VaultSecretGroupArgs',
      'VirtualHardDiskArgs',
      'VirtualMachineExtensionInstanceViewArgs',
      'VirtualMachineIdentityArgs',
      'VirtualMachineScaleSetDataDiskArgs',
      'VirtualMachineScaleSetExtensionArgs',
      'VirtualMachineScaleSetExtensionProfileArgs',
      'VirtualMachineScaleSetIPConfigurationArgs',
      'VirtualMachineScaleSetIdentityArgs',
      'VirtualMachineScaleSetIpTagArgs',
      'VirtualMachineScaleSetManagedDiskParametersArgs',
      'VirtualMachineScaleSetNetworkConfigurationArgs',
      'VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs',
      'VirtualMachineScaleSetNetworkProfileArgs',
      'VirtualMachineScaleSetOSDiskArgs',
      'VirtualMachineScaleSetOSProfileArgs',
      'VirtualMachineScaleSetPublicIPAddressConfigurationArgs',
      'VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs',
      'VirtualMachineScaleSetStorageProfileArgs',
      'VirtualMachineScaleSetVMNetworkProfileConfigurationArgs',
      'VirtualMachineScaleSetVMProfileArgs',
      'VirtualMachineScaleSetVMProtectionPolicyArgs',
      'WinRMConfigurationArgs',
      'WinRMListenerArgs',
      'WindowsConfigurationArgs',
  ]
  
  @pulumi.input_type
  class AdditionalCapabilitiesArgs:
      def __init__(__self__, *,
                   ultra_ssd_enabled: Optional[pulumi.Input[bool]] = None):
          """
          Enables or disables a capability on the virtual machine or virtual machine scale set.
          :param pulumi.Input[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[pulumi.Input[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")
  
      @ultra_ssd_enabled.setter
      def ultra_ssd_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ultra_ssd_enabled", value)
  
  
  @pulumi.input_type
  class AdditionalUnattendContentArgs:
      def __init__(__self__, *,
                   component_name: Optional[pulumi.Input['ComponentNames']] = None,
                   content: Optional[pulumi.Input[str]] = None,
                   pass_name: Optional[pulumi.Input['PassNames']] = None,
                   setting_name: Optional[pulumi.Input['SettingNames']] = 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 pulumi.Input['ComponentNames'] component_name: The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
          :param pulumi.Input[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 pulumi.Input['PassNames'] pass_name: The pass name. Currently, the only allowable value is OobeSystem.
          :param pulumi.Input['SettingNames'] 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[pulumi.Input['ComponentNames']]:
          """
          The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup.
          """
          return pulumi.get(self, "component_name")
  
      @component_name.setter
      def component_name(self, value: Optional[pulumi.Input['ComponentNames']]):
          pulumi.set(self, "component_name", value)
  
      @property
      @pulumi.getter
      def content(self) -> Optional[pulumi.Input[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")
  
      @content.setter
      def content(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "content", value)
  
      @property
      @pulumi.getter(name="passName")
      def pass_name(self) -> Optional[pulumi.Input['PassNames']]:
          """
          The pass name. Currently, the only allowable value is OobeSystem.
          """
          return pulumi.get(self, "pass_name")
  
      @pass_name.setter
      def pass_name(self, value: Optional[pulumi.Input['PassNames']]):
          pulumi.set(self, "pass_name", value)
  
      @property
      @pulumi.getter(name="settingName")
      def setting_name(self) -> Optional[pulumi.Input['SettingNames']]:
          """
          Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
          """
          return pulumi.get(self, "setting_name")
  
      @setting_name.setter
      def setting_name(self, value: Optional[pulumi.Input['SettingNames']]):
          pulumi.set(self, "setting_name", value)
  
  
  @pulumi.input_type
  class ApiEntityReferenceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          The API entity reference.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class AutomaticOSUpgradePolicyArgs:
      def __init__(__self__, *,
                   disable_automatic_rollback: Optional[pulumi.Input[bool]] = None,
                   enable_automatic_os_upgrade: Optional[pulumi.Input[bool]] = None):
          """
          The configuration parameters used for performing automatic OS upgrade.
          :param pulumi.Input[bool] disable_automatic_rollback: Whether OS image rollback feature should be disabled. Default value is false.
          :param pulumi.Input[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[pulumi.Input[bool]]:
          """
          Whether OS image rollback feature should be disabled. Default value is false.
          """
          return pulumi.get(self, "disable_automatic_rollback")
  
      @disable_automatic_rollback.setter
      def disable_automatic_rollback(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "disable_automatic_rollback", value)
  
      @property
      @pulumi.getter(name="enableAutomaticOSUpgrade")
      def enable_automatic_os_upgrade(self) -> Optional[pulumi.Input[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")
  
      @enable_automatic_os_upgrade.setter
      def enable_automatic_os_upgrade(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_automatic_os_upgrade", value)
  
  
  @pulumi.input_type
  class AutomaticRepairsPolicyArgs:
      def __init__(__self__, *,
                   enabled: Optional[pulumi.Input[bool]] = None,
                   grace_period: Optional[pulumi.Input[str]] = None):
          """
          Specifies the configuration parameters for automatic repairs on the virtual machine scale set.
          :param pulumi.Input[bool] enabled: Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
          :param pulumi.Input[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[pulumi.Input[bool]]:
          """
          Specifies whether automatic repairs should be enabled on the virtual machine scale set. The default value is false.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="gracePeriod")
      def grace_period(self) -> Optional[pulumi.Input[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")
  
      @grace_period.setter
      def grace_period(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "grace_period", value)
  
  
  @pulumi.input_type
  class BillingProfileArgs:
      def __init__(__self__, *,
                   max_price: Optional[pulumi.Input[float]] = None):
          """
          Specifies the billing related details of a Azure Spot VM or VMSS. <br><br>Minimum api-version: 2019-03-01.
          :param pulumi.Input[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[pulumi.Input[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")
  
      @max_price.setter
      def max_price(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "max_price", value)
  
  
  @pulumi.input_type
  class BootDiagnosticsArgs:
      def __init__(__self__, *,
                   enabled: Optional[pulumi.Input[bool]] = None,
                   storage_uri: Optional[pulumi.Input[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 pulumi.Input[bool] enabled: Whether boot diagnostics should be enabled on the Virtual Machine.
          :param pulumi.Input[str] storage_uri: Uri of the storage account to use for placing the console output and screenshot.
          """
          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[pulumi.Input[bool]]:
          """
          Whether boot diagnostics should be enabled on the Virtual Machine.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="storageUri")
      def storage_uri(self) -> Optional[pulumi.Input[str]]:
          """
          Uri of the storage account to use for placing the console output and screenshot.
          """
          return pulumi.get(self, "storage_uri")
  
      @storage_uri.setter
      def storage_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "storage_uri", value)
  
  
  @pulumi.input_type
  class CreationDataArgs:
      def __init__(__self__, *,
                   create_option: pulumi.Input[Union[str, 'DiskCreateOption']],
                   image_reference: Optional[pulumi.Input['ImageDiskReferenceArgs']] = None,
                   source_resource_id: Optional[pulumi.Input[str]] = None,
                   source_uri: Optional[pulumi.Input[str]] = None,
                   storage_account_id: Optional[pulumi.Input[str]] = None,
                   upload_size_bytes: Optional[pulumi.Input[float]] = None):
          """
          Data used when creating a disk.
          :param pulumi.Input[Union[str, 'DiskCreateOption']] create_option: This enumerates the possible sources of a disk's creation.
          :param pulumi.Input['ImageDiskReferenceArgs'] image_reference: Disk source information.
          :param pulumi.Input[str] source_resource_id: If createOption is Copy, this is the ARM id of the source snapshot or disk.
          :param pulumi.Input[str] source_uri: If createOption is Import, this is the URI of a blob to be imported into a managed disk.
          :param pulumi.Input[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 pulumi.Input[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)
          if image_reference is not None:
              pulumi.set(__self__, "image_reference", image_reference)
          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) -> pulumi.Input[Union[str, 'DiskCreateOption']]:
          """
          This enumerates the possible sources of a disk's creation.
          """
          return pulumi.get(self, "create_option")
  
      @create_option.setter
      def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOption']]):
          pulumi.set(self, "create_option", value)
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional[pulumi.Input['ImageDiskReferenceArgs']]:
          """
          Disk source information.
          """
          return pulumi.get(self, "image_reference")
  
      @image_reference.setter
      def image_reference(self, value: Optional[pulumi.Input['ImageDiskReferenceArgs']]):
          pulumi.set(self, "image_reference", value)
  
      @property
      @pulumi.getter(name="sourceResourceId")
      def source_resource_id(self) -> Optional[pulumi.Input[str]]:
          """
          If createOption is Copy, this is the ARM id of the source snapshot or disk.
          """
          return pulumi.get(self, "source_resource_id")
  
      @source_resource_id.setter
      def source_resource_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source_resource_id", value)
  
      @property
      @pulumi.getter(name="sourceUri")
      def source_uri(self) -> Optional[pulumi.Input[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")
  
      @source_uri.setter
      def source_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source_uri", value)
  
      @property
      @pulumi.getter(name="storageAccountId")
      def storage_account_id(self) -> Optional[pulumi.Input[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")
  
      @storage_account_id.setter
      def storage_account_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "storage_account_id", value)
  
      @property
      @pulumi.getter(name="uploadSizeBytes")
      def upload_size_bytes(self) -> Optional[pulumi.Input[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")
  
      @upload_size_bytes.setter
      def upload_size_bytes(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "upload_size_bytes", value)
  
  
  @pulumi.input_type
  class DataDiskArgs:
      def __init__(__self__, *,
                   create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
                   lun: pulumi.Input[int],
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
                   managed_disk: Optional[pulumi.Input['ManagedDiskParametersArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   to_be_detached: Optional[pulumi.Input[bool]] = None,
                   vhd: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
                   write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
          """
          Describes a data disk.
          :param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] 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 pulumi.Input[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 pulumi.Input['CachingTypes'] 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 pulumi.Input[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 pulumi.Input['VirtualHardDiskArgs'] 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 pulumi.Input['ManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
          :param pulumi.Input[str] name: The disk name.
          :param pulumi.Input[bool] to_be_detached: Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
          :param pulumi.Input['VirtualHardDiskArgs'] vhd: The virtual hard disk.
          :param pulumi.Input[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_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) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
          """
          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")
  
      @create_option.setter
      def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
          pulumi.set(self, "create_option", value)
  
      @property
      @pulumi.getter
      def lun(self) -> pulumi.Input[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")
  
      @lun.setter
      def lun(self, value: pulumi.Input[int]):
          pulumi.set(self, "lun", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter
      def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
          """
          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")
  
      @image.setter
      def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
          pulumi.set(self, "image", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['ManagedDiskParametersArgs']]:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['ManagedDiskParametersArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="toBeDetached")
      def to_be_detached(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether the data disk is in process of detachment from the VirtualMachine/VirtualMachineScaleset
          """
          return pulumi.get(self, "to_be_detached")
  
      @to_be_detached.setter
      def to_be_detached(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "to_be_detached", value)
  
      @property
      @pulumi.getter
      def vhd(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
          """
          The virtual hard disk.
          """
          return pulumi.get(self, "vhd")
  
      @vhd.setter
      def vhd(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
          pulumi.set(self, "vhd", value)
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      @write_accelerator_enabled.setter
      def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "write_accelerator_enabled", value)
  
  
  @pulumi.input_type
  class DiagnosticsProfileArgs:
      def __init__(__self__, *,
                   boot_diagnostics: Optional[pulumi.Input['BootDiagnosticsArgs']] = None):
          """
          Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          :param pulumi.Input['BootDiagnosticsArgs'] 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[pulumi.Input['BootDiagnosticsArgs']]:
          """
          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")
  
      @boot_diagnostics.setter
      def boot_diagnostics(self, value: Optional[pulumi.Input['BootDiagnosticsArgs']]):
          pulumi.set(self, "boot_diagnostics", value)
  
  
  @pulumi.input_type
  class DiffDiskSettingsArgs:
      def __init__(__self__, *,
                   option: Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]] = 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 pulumi.Input[Union[str, 'DiffDiskOptions']] option: Specifies the ephemeral disk settings for operating system disk.
          """
          if option is not None:
              pulumi.set(__self__, "option", option)
  
      @property
      @pulumi.getter
      def option(self) -> Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]]:
          """
          Specifies the ephemeral disk settings for operating system disk.
          """
          return pulumi.get(self, "option")
  
      @option.setter
      def option(self, value: Optional[pulumi.Input[Union[str, 'DiffDiskOptions']]]):
          pulumi.set(self, "option", value)
  
  
  @pulumi.input_type
  class DisallowedArgs:
      def __init__(__self__, *,
                   disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Describes the disallowed disk types.
          :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of disk types.
          """
          return pulumi.get(self, "disk_types")
  
      @disk_types.setter
      def disk_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "disk_types", value)
  
  
  @pulumi.input_type
  class DiskEncryptionSetParametersArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[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 pulumi.Input[str] id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class DiskEncryptionSettingsArgs:
      def __init__(__self__, *,
                   disk_encryption_key: Optional[pulumi.Input['KeyVaultSecretReferenceArgs']] = None,
                   enabled: Optional[pulumi.Input[bool]] = None,
                   key_encryption_key: Optional[pulumi.Input['KeyVaultKeyReferenceArgs']] = None):
          """
          Describes a Encryption Settings for a Disk
          :param pulumi.Input['KeyVaultSecretReferenceArgs'] disk_encryption_key: Specifies the location of the disk encryption key, which is a Key Vault Secret.
          :param pulumi.Input[bool] enabled: Specifies whether disk encryption should be enabled on the virtual machine.
          :param pulumi.Input['KeyVaultKeyReferenceArgs'] 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[pulumi.Input['KeyVaultSecretReferenceArgs']]:
          """
          Specifies the location of the disk encryption key, which is a Key Vault Secret.
          """
          return pulumi.get(self, "disk_encryption_key")
  
      @disk_encryption_key.setter
      def disk_encryption_key(self, value: Optional[pulumi.Input['KeyVaultSecretReferenceArgs']]):
          pulumi.set(self, "disk_encryption_key", value)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether disk encryption should be enabled on the virtual machine.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="keyEncryptionKey")
      def key_encryption_key(self) -> Optional[pulumi.Input['KeyVaultKeyReferenceArgs']]:
          """
          Specifies the location of the key encryption key in Key Vault.
          """
          return pulumi.get(self, "key_encryption_key")
  
      @key_encryption_key.setter
      def key_encryption_key(self, value: Optional[pulumi.Input['KeyVaultKeyReferenceArgs']]):
          pulumi.set(self, "key_encryption_key", value)
  
  
  @pulumi.input_type
  class DiskSkuArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[Union[str, 'DiskStorageAccountTypes']]] = None):
          """
          The disks sku name. Can be Standard_LRS, Premium_LRS, StandardSSD_LRS, or UltraSSD_LRS.
          :param pulumi.Input[Union[str, 'DiskStorageAccountTypes']] name: The sku name.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'DiskStorageAccountTypes']]]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'DiskStorageAccountTypes']]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class EncryptionArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[Union[str, 'EncryptionType']],
                   disk_encryption_set_id: Optional[pulumi.Input[str]] = None):
          """
          Encryption at rest settings for disk or snapshot
          :param pulumi.Input[Union[str, 'EncryptionType']] type: The type of key used to encrypt the data of the disk.
          :param pulumi.Input[str] disk_encryption_set_id: ResourceId of the disk encryption set to use for enabling encryption at rest.
          """
          pulumi.set(__self__, "type", type)
          if disk_encryption_set_id is not None:
              pulumi.set(__self__, "disk_encryption_set_id", disk_encryption_set_id)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[Union[str, 'EncryptionType']]:
          """
          The type of key used to encrypt the data of the disk.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[Union[str, 'EncryptionType']]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="diskEncryptionSetId")
      def disk_encryption_set_id(self) -> Optional[pulumi.Input[str]]:
          """
          ResourceId of the disk encryption set to use for enabling encryption at rest.
          """
          return pulumi.get(self, "disk_encryption_set_id")
  
      @disk_encryption_set_id.setter
      def disk_encryption_set_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_encryption_set_id", value)
  
  
  @pulumi.input_type
  class EncryptionSetIdentityArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input[Union[str, 'DiskEncryptionSetIdentityType']]] = 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 pulumi.Input[Union[str, 'DiskEncryptionSetIdentityType']] type: The type of Managed Identity used by the DiskEncryptionSet. Only SystemAssigned is supported.
          """
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[Union[str, 'DiskEncryptionSetIdentityType']]]:
          """
          The type of Managed Identity used by the DiskEncryptionSet. Only SystemAssigned is supported.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[Union[str, 'DiskEncryptionSetIdentityType']]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class EncryptionSettingsCollectionArgs:
      def __init__(__self__, *,
                   enabled: pulumi.Input[bool],
                   encryption_settings: Optional[pulumi.Input[Sequence[pulumi.Input['EncryptionSettingsElementArgs']]]] = None,
                   encryption_settings_version: Optional[pulumi.Input[str]] = None):
          """
          Encryption settings for disk or snapshot
          :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input['EncryptionSettingsElementArgs']]] encryption_settings: A collection of encryption settings, one for each disk volume.
          :param pulumi.Input[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) -> pulumi.Input[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")
  
      @enabled.setter
      def enabled(self, value: pulumi.Input[bool]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="encryptionSettings")
      def encryption_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EncryptionSettingsElementArgs']]]]:
          """
          A collection of encryption settings, one for each disk volume.
          """
          return pulumi.get(self, "encryption_settings")
  
      @encryption_settings.setter
      def encryption_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EncryptionSettingsElementArgs']]]]):
          pulumi.set(self, "encryption_settings", value)
  
      @property
      @pulumi.getter(name="encryptionSettingsVersion")
      def encryption_settings_version(self) -> Optional[pulumi.Input[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")
  
      @encryption_settings_version.setter
      def encryption_settings_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "encryption_settings_version", value)
  
  
  @pulumi.input_type
  class EncryptionSettingsElementArgs:
      def __init__(__self__, *,
                   disk_encryption_key: Optional[pulumi.Input['KeyVaultAndSecretReferenceArgs']] = None,
                   key_encryption_key: Optional[pulumi.Input['KeyVaultAndKeyReferenceArgs']] = None):
          """
          Encryption settings for one disk volume.
          :param pulumi.Input['KeyVaultAndSecretReferenceArgs'] disk_encryption_key: Key Vault Secret Url and vault id of the disk encryption key
          :param pulumi.Input['KeyVaultAndKeyReferenceArgs'] 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[pulumi.Input['KeyVaultAndSecretReferenceArgs']]:
          """
          Key Vault Secret Url and vault id of the disk encryption key
          """
          return pulumi.get(self, "disk_encryption_key")
  
      @disk_encryption_key.setter
      def disk_encryption_key(self, value: Optional[pulumi.Input['KeyVaultAndSecretReferenceArgs']]):
          pulumi.set(self, "disk_encryption_key", value)
  
      @property
      @pulumi.getter(name="keyEncryptionKey")
      def key_encryption_key(self) -> Optional[pulumi.Input['KeyVaultAndKeyReferenceArgs']]:
          """
          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")
  
      @key_encryption_key.setter
      def key_encryption_key(self, value: Optional[pulumi.Input['KeyVaultAndKeyReferenceArgs']]):
          pulumi.set(self, "key_encryption_key", value)
  
  
  @pulumi.input_type
  class GalleryApplicationVersionPublishingProfileArgs:
      def __init__(__self__, *,
                   source: pulumi.Input['UserArtifactSourceArgs'],
                   enable_health_check: Optional[pulumi.Input[bool]] = None,
                   end_of_life_date: Optional[pulumi.Input[str]] = None,
                   exclude_from_latest: Optional[pulumi.Input[bool]] = None,
                   manage_actions: Optional[pulumi.Input['UserArtifactManageArgs']] = None,
                   replica_count: Optional[pulumi.Input[int]] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None,
                   target_regions: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]] = None):
          """
          The publishing profile of a gallery image version.
          :param pulumi.Input['UserArtifactSourceArgs'] source: The source image from which the Image Version is going to be created.
          :param pulumi.Input[bool] enable_health_check: Optional. Whether or not this application reports health.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[Union[str, 'StorageAccountType']] storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
          :param pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          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
      def source(self) -> pulumi.Input['UserArtifactSourceArgs']:
          """
          The source image from which the Image Version is going to be created.
          """
          return pulumi.get(self, "source")
  
      @source.setter
      def source(self, value: pulumi.Input['UserArtifactSourceArgs']):
          pulumi.set(self, "source", value)
  
      @property
      @pulumi.getter(name="enableHealthCheck")
      def enable_health_check(self) -> Optional[pulumi.Input[bool]]:
          """
          Optional. Whether or not this application reports health.
          """
          return pulumi.get(self, "enable_health_check")
  
      @enable_health_check.setter
      def enable_health_check(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_health_check", value)
  
      @property
      @pulumi.getter(name="endOfLifeDate")
      def end_of_life_date(self) -> Optional[pulumi.Input[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")
  
      @end_of_life_date.setter
      def end_of_life_date(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "end_of_life_date", value)
  
      @property
      @pulumi.getter(name="excludeFromLatest")
      def exclude_from_latest(self) -> Optional[pulumi.Input[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")
  
      @exclude_from_latest.setter
      def exclude_from_latest(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "exclude_from_latest", value)
  
      @property
      @pulumi.getter(name="manageActions")
      def manage_actions(self) -> Optional[pulumi.Input['UserArtifactManageArgs']]:
          return pulumi.get(self, "manage_actions")
  
      @manage_actions.setter
      def manage_actions(self, value: Optional[pulumi.Input['UserArtifactManageArgs']]):
          pulumi.set(self, "manage_actions", value)
  
      @property
      @pulumi.getter(name="replicaCount")
      def replica_count(self) -> Optional[pulumi.Input[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")
  
      @replica_count.setter
      def replica_count(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replica_count", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
          pulumi.set(self, "storage_account_type", value)
  
      @property
      @pulumi.getter(name="targetRegions")
      def target_regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]:
          """
          The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          return pulumi.get(self, "target_regions")
  
      @target_regions.setter
      def target_regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]):
          pulumi.set(self, "target_regions", value)
  
  
  @pulumi.input_type
  class GalleryArtifactVersionSourceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          The gallery artifact version source.
          :param pulumi.Input[str] id: The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, or user image.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          The id of the gallery artifact version source. Can specify a disk uri, snapshot uri, or user image.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class GalleryDataDiskImageArgs:
      def __init__(__self__, *,
                   lun: pulumi.Input[int],
                   host_caching: Optional[pulumi.Input['HostCaching']] = None,
                   source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
          """
          This is the data disk image.
          :param pulumi.Input[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 pulumi.Input['HostCaching'] host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          :param pulumi.Input['GalleryArtifactVersionSourceArgs'] source: The gallery artifact version source.
          """
          pulumi.set(__self__, "lun", lun)
          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) -> pulumi.Input[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")
  
      @lun.setter
      def lun(self, value: pulumi.Input[int]):
          pulumi.set(self, "lun", value)
  
      @property
      @pulumi.getter(name="hostCaching")
      def host_caching(self) -> Optional[pulumi.Input['HostCaching']]:
          """
          The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          """
          return pulumi.get(self, "host_caching")
  
      @host_caching.setter
      def host_caching(self, value: Optional[pulumi.Input['HostCaching']]):
          pulumi.set(self, "host_caching", value)
  
      @property
      @pulumi.getter
      def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      @source.setter
      def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
          pulumi.set(self, "source", value)
  
  
  @pulumi.input_type
  class GalleryImageIdentifierArgs:
      def __init__(__self__, *,
                   offer: pulumi.Input[str],
                   publisher: pulumi.Input[str],
                   sku: pulumi.Input[str]):
          """
          This is the gallery Image Definition identifier.
          :param pulumi.Input[str] offer: The name of the gallery Image Definition offer.
          :param pulumi.Input[str] publisher: The name of the gallery Image Definition publisher.
          :param pulumi.Input[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) -> pulumi.Input[str]:
          """
          The name of the gallery Image Definition offer.
          """
          return pulumi.get(self, "offer")
  
      @offer.setter
      def offer(self, value: pulumi.Input[str]):
          pulumi.set(self, "offer", value)
  
      @property
      @pulumi.getter
      def publisher(self) -> pulumi.Input[str]:
          """
          The name of the gallery Image Definition publisher.
          """
          return pulumi.get(self, "publisher")
  
      @publisher.setter
      def publisher(self, value: pulumi.Input[str]):
          pulumi.set(self, "publisher", value)
  
      @property
      @pulumi.getter
      def sku(self) -> pulumi.Input[str]:
          """
          The name of the gallery Image Definition SKU.
          """
          return pulumi.get(self, "sku")
  
      @sku.setter
      def sku(self, value: pulumi.Input[str]):
          pulumi.set(self, "sku", value)
  
  
  @pulumi.input_type
  class GalleryImageVersionPublishingProfileArgs:
      def __init__(__self__, *,
                   end_of_life_date: Optional[pulumi.Input[str]] = None,
                   exclude_from_latest: Optional[pulumi.Input[bool]] = None,
                   replica_count: Optional[pulumi.Input[int]] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None,
                   target_regions: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]] = None):
          """
          The publishing profile of a gallery Image Version.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[Union[str, 'StorageAccountType']] storage_account_type: Specifies the storage account type to be used to store the image. This property is not updatable.
          :param pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]] target_regions: The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          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="endOfLifeDate")
      def end_of_life_date(self) -> Optional[pulumi.Input[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")
  
      @end_of_life_date.setter
      def end_of_life_date(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "end_of_life_date", value)
  
      @property
      @pulumi.getter(name="excludeFromLatest")
      def exclude_from_latest(self) -> Optional[pulumi.Input[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")
  
      @exclude_from_latest.setter
      def exclude_from_latest(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "exclude_from_latest", value)
  
      @property
      @pulumi.getter(name="replicaCount")
      def replica_count(self) -> Optional[pulumi.Input[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")
  
      @replica_count.setter
      def replica_count(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replica_count", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
          pulumi.set(self, "storage_account_type", value)
  
      @property
      @pulumi.getter(name="targetRegions")
      def target_regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]:
          """
          The target regions where the Image Version is going to be replicated to. This property is updatable.
          """
          return pulumi.get(self, "target_regions")
  
      @target_regions.setter
      def target_regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetRegionArgs']]]]):
          pulumi.set(self, "target_regions", value)
  
  
  @pulumi.input_type
  class GalleryImageVersionStorageProfileArgs:
      def __init__(__self__, *,
                   data_disk_images: Optional[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]] = None,
                   os_disk_image: Optional[pulumi.Input['GalleryOSDiskImageArgs']] = None,
                   source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
          """
          This is the storage profile of a Gallery Image Version.
          :param pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]] data_disk_images: A list of data disk images.
          :param pulumi.Input['GalleryOSDiskImageArgs'] os_disk_image: This is the OS disk image.
          :param pulumi.Input['GalleryArtifactVersionSourceArgs'] 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[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]]:
          """
          A list of data disk images.
          """
          return pulumi.get(self, "data_disk_images")
  
      @data_disk_images.setter
      def data_disk_images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GalleryDataDiskImageArgs']]]]):
          pulumi.set(self, "data_disk_images", value)
  
      @property
      @pulumi.getter(name="osDiskImage")
      def os_disk_image(self) -> Optional[pulumi.Input['GalleryOSDiskImageArgs']]:
          """
          This is the OS disk image.
          """
          return pulumi.get(self, "os_disk_image")
  
      @os_disk_image.setter
      def os_disk_image(self, value: Optional[pulumi.Input['GalleryOSDiskImageArgs']]):
          pulumi.set(self, "os_disk_image", value)
  
      @property
      @pulumi.getter
      def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      @source.setter
      def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
          pulumi.set(self, "source", value)
  
  
  @pulumi.input_type
  class GalleryOSDiskImageArgs:
      def __init__(__self__, *,
                   host_caching: Optional[pulumi.Input['HostCaching']] = None,
                   source: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']] = None):
          """
          This is the OS disk image.
          :param pulumi.Input['HostCaching'] host_caching: The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          :param pulumi.Input['GalleryArtifactVersionSourceArgs'] source: The gallery artifact version source.
          """
          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="hostCaching")
      def host_caching(self) -> Optional[pulumi.Input['HostCaching']]:
          """
          The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
          """
          return pulumi.get(self, "host_caching")
  
      @host_caching.setter
      def host_caching(self, value: Optional[pulumi.Input['HostCaching']]):
          pulumi.set(self, "host_caching", value)
  
      @property
      @pulumi.getter
      def source(self) -> Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]:
          """
          The gallery artifact version source.
          """
          return pulumi.get(self, "source")
  
      @source.setter
      def source(self, value: Optional[pulumi.Input['GalleryArtifactVersionSourceArgs']]):
          pulumi.set(self, "source", value)
  
  
  @pulumi.input_type
  class HardwareProfileArgs:
      def __init__(__self__, *,
                   vm_size: Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]] = None):
          """
          Specifies the hardware settings for the virtual machine.
          :param pulumi.Input[Union[str, 'VirtualMachineSizeTypes']] vm_size: Specifies the size of the virtual machine. For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-sizes?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json). <br><br> The available VM sizes depend on region and availability set. For a list of available sizes use 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/rest/api/compute/virtualmachinesizes/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes)
          """
          if vm_size is not None:
              pulumi.set(__self__, "vm_size", vm_size)
  
      @property
      @pulumi.getter(name="vmSize")
      def vm_size(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]]:
          """
          Specifies the size of the virtual machine. For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-sizes?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json). <br><br> The available VM sizes depend on region and availability set. For a list of available sizes use 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/rest/api/compute/virtualmachinesizes/list) <br><br> [List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes)
          """
          return pulumi.get(self, "vm_size")
  
      @vm_size.setter
      def vm_size(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachineSizeTypes']]]):
          pulumi.set(self, "vm_size", value)
  
  
  @pulumi.input_type
  class ImageDataDiskArgs:
      def __init__(__self__, *,
                   lun: pulumi.Input[int],
                   blob_uri: Optional[pulumi.Input[str]] = None,
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   managed_disk: Optional[pulumi.Input['SubResourceArgs']] = None,
                   snapshot: Optional[pulumi.Input['SubResourceArgs']] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
          """
          Describes a data disk.
          :param pulumi.Input[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 pulumi.Input[str] blob_uri: The Virtual Hard Disk.
          :param pulumi.Input['CachingTypes'] 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 pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
          :param pulumi.Input[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 pulumi.Input['SubResourceArgs'] managed_disk: The managedDisk.
          :param pulumi.Input['SubResourceArgs'] snapshot: The snapshot.
          :param pulumi.Input[Union[str, 'StorageAccountTypes']] 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) -> pulumi.Input[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")
  
      @lun.setter
      def lun(self, value: pulumi.Input[int]):
          pulumi.set(self, "lun", value)
  
      @property
      @pulumi.getter(name="blobUri")
      def blob_uri(self) -> Optional[pulumi.Input[str]]:
          """
          The Virtual Hard Disk.
          """
          return pulumi.get(self, "blob_uri")
  
      @blob_uri.setter
      def blob_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "blob_uri", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
          """
          Specifies the customer managed disk encryption set resource id for the managed image disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @disk_encryption_set.setter
      def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
          pulumi.set(self, "disk_encryption_set", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The managedDisk.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def snapshot(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The snapshot.
          """
          return pulumi.get(self, "snapshot")
  
      @snapshot.setter
      def snapshot(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "snapshot", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
          """
          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")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
          pulumi.set(self, "storage_account_type", value)
  
  
  @pulumi.input_type
  class ImageDiskReferenceArgs:
      def __init__(__self__, *,
                   id: pulumi.Input[str],
                   lun: Optional[pulumi.Input[int]] = None):
          """
          The source image used for creating the disk.
          :param pulumi.Input[str] id: A relative uri containing either a Platform Image Repository or user image reference.
          :param pulumi.Input[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) -> pulumi.Input[str]:
          """
          A relative uri containing either a Platform Image Repository or user image reference.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: pulumi.Input[str]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def lun(self) -> Optional[pulumi.Input[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")
  
      @lun.setter
      def lun(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "lun", value)
  
  
  @pulumi.input_type
  class ImageOSDiskArgs:
      def __init__(__self__, *,
                   os_state: pulumi.Input['OperatingSystemStateTypes'],
                   os_type: pulumi.Input['OperatingSystemTypes'],
                   blob_uri: Optional[pulumi.Input[str]] = None,
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   managed_disk: Optional[pulumi.Input['SubResourceArgs']] = None,
                   snapshot: Optional[pulumi.Input['SubResourceArgs']] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
          """
          Describes an Operating System disk.
          :param pulumi.Input['OperatingSystemStateTypes'] os_state: The OS State.
          :param pulumi.Input['OperatingSystemTypes'] 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 pulumi.Input[str] blob_uri: The Virtual Hard Disk.
          :param pulumi.Input['CachingTypes'] 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 pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed image disk.
          :param pulumi.Input[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 pulumi.Input['SubResourceArgs'] managed_disk: The managedDisk.
          :param pulumi.Input['SubResourceArgs'] snapshot: The snapshot.
          :param pulumi.Input[Union[str, 'StorageAccountTypes']] 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) -> pulumi.Input['OperatingSystemStateTypes']:
          """
          The OS State.
          """
          return pulumi.get(self, "os_state")
  
      @os_state.setter
      def os_state(self, value: pulumi.Input['OperatingSystemStateTypes']):
          pulumi.set(self, "os_state", value)
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> pulumi.Input['OperatingSystemTypes']:
          """
          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")
  
      @os_type.setter
      def os_type(self, value: pulumi.Input['OperatingSystemTypes']):
          pulumi.set(self, "os_type", value)
  
      @property
      @pulumi.getter(name="blobUri")
      def blob_uri(self) -> Optional[pulumi.Input[str]]:
          """
          The Virtual Hard Disk.
          """
          return pulumi.get(self, "blob_uri")
  
      @blob_uri.setter
      def blob_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "blob_uri", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diskEncryptionSet")
      def disk_encryption_set(self) -> Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]:
          """
          Specifies the customer managed disk encryption set resource id for the managed image disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @disk_encryption_set.setter
      def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
          pulumi.set(self, "disk_encryption_set", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The managedDisk.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def snapshot(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The snapshot.
          """
          return pulumi.get(self, "snapshot")
  
      @snapshot.setter
      def snapshot(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "snapshot", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
          """
          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")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
          pulumi.set(self, "storage_account_type", value)
  
  
  @pulumi.input_type
  class ImagePurchasePlanArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[str]] = None,
                   product: Optional[pulumi.Input[str]] = None,
                   publisher: Optional[pulumi.Input[str]] = None):
          """
          Describes the gallery Image Definition purchase plan. This is used by marketplace images.
          :param pulumi.Input[str] name: The plan ID.
          :param pulumi.Input[str] product: The product ID.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          The plan ID.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def product(self) -> Optional[pulumi.Input[str]]:
          """
          The product ID.
          """
          return pulumi.get(self, "product")
  
      @product.setter
      def product(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "product", value)
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[pulumi.Input[str]]:
          """
          The publisher ID.
          """
          return pulumi.get(self, "publisher")
  
      @publisher.setter
      def publisher(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "publisher", value)
  
  
  @pulumi.input_type
  class ImageReferenceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   offer: Optional[pulumi.Input[str]] = None,
                   publisher: Optional[pulumi.Input[str]] = None,
                   sku: Optional[pulumi.Input[str]] = None,
                   version: Optional[pulumi.Input[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 pulumi.Input[str] id: Resource Id
          :param pulumi.Input[str] offer: Specifies the offer of the platform image or marketplace image used to create the virtual machine.
          :param pulumi.Input[str] publisher: The image publisher.
          :param pulumi.Input[str] sku: The image SKU.
          :param pulumi.Input[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.
          """
          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
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def offer(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the offer of the platform image or marketplace image used to create the virtual machine.
          """
          return pulumi.get(self, "offer")
  
      @offer.setter
      def offer(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "offer", value)
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[pulumi.Input[str]]:
          """
          The image publisher.
          """
          return pulumi.get(self, "publisher")
  
      @publisher.setter
      def publisher(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "publisher", value)
  
      @property
      @pulumi.getter
      def sku(self) -> Optional[pulumi.Input[str]]:
          """
          The image SKU.
          """
          return pulumi.get(self, "sku")
  
      @sku.setter
      def sku(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sku", value)
  
      @property
      @pulumi.getter
      def version(self) -> Optional[pulumi.Input[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")
  
      @version.setter
      def version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "version", value)
  
  
  @pulumi.input_type
  class ImageStorageProfileArgs:
      def __init__(__self__, *,
                   data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]] = None,
                   os_disk: Optional[pulumi.Input['ImageOSDiskArgs']] = None,
                   zone_resilient: Optional[pulumi.Input[bool]] = None):
          """
          Describes a storage profile.
          :param pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]] 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 pulumi.Input['ImageOSDiskArgs'] 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 pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]]:
          """
          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")
  
      @data_disks.setter
      def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ImageDataDiskArgs']]]]):
          pulumi.set(self, "data_disks", value)
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional[pulumi.Input['ImageOSDiskArgs']]:
          """
          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")
  
      @os_disk.setter
      def os_disk(self, value: Optional[pulumi.Input['ImageOSDiskArgs']]):
          pulumi.set(self, "os_disk", value)
  
      @property
      @pulumi.getter(name="zoneResilient")
      def zone_resilient(self) -> Optional[pulumi.Input[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")
  
      @zone_resilient.setter
      def zone_resilient(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "zone_resilient", value)
  
  
  @pulumi.input_type
  class InstanceViewStatusArgs:
      def __init__(__self__, *,
                   code: Optional[pulumi.Input[str]] = None,
                   display_status: Optional[pulumi.Input[str]] = None,
                   level: Optional[pulumi.Input['StatusLevelTypes']] = None,
                   message: Optional[pulumi.Input[str]] = None,
                   time: Optional[pulumi.Input[str]] = None):
          """
          Instance view status.
          :param pulumi.Input[str] code: The status code.
          :param pulumi.Input[str] display_status: The short localizable label for the status.
          :param pulumi.Input['StatusLevelTypes'] level: The level code.
          :param pulumi.Input[str] message: The detailed status message, including for alerts and error messages.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          The status code.
          """
          return pulumi.get(self, "code")
  
      @code.setter
      def code(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "code", value)
  
      @property
      @pulumi.getter(name="displayStatus")
      def display_status(self) -> Optional[pulumi.Input[str]]:
          """
          The short localizable label for the status.
          """
          return pulumi.get(self, "display_status")
  
      @display_status.setter
      def display_status(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "display_status", value)
  
      @property
      @pulumi.getter
      def level(self) -> Optional[pulumi.Input['StatusLevelTypes']]:
          """
          The level code.
          """
          return pulumi.get(self, "level")
  
      @level.setter
      def level(self, value: Optional[pulumi.Input['StatusLevelTypes']]):
          pulumi.set(self, "level", value)
  
      @property
      @pulumi.getter
      def message(self) -> Optional[pulumi.Input[str]]:
          """
          The detailed status message, including for alerts and error messages.
          """
          return pulumi.get(self, "message")
  
      @message.setter
      def message(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "message", value)
  
      @property
      @pulumi.getter
      def time(self) -> Optional[pulumi.Input[str]]:
          """
          The time of the status.
          """
          return pulumi.get(self, "time")
  
      @time.setter
      def time(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "time", value)
  
  
  @pulumi.input_type
  class KeyVaultAndKeyReferenceArgs:
      def __init__(__self__, *,
                   key_url: pulumi.Input[str],
                   source_vault: pulumi.Input['SourceVaultArgs']):
          """
          Key Vault Key Url and vault id of KeK, KeK is optional and when provided is used to unwrap the encryptionKey
          :param pulumi.Input[str] key_url: Url pointing to a key or secret in KeyVault
          :param pulumi.Input['SourceVaultArgs'] 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) -> pulumi.Input[str]:
          """
          Url pointing to a key or secret in KeyVault
          """
          return pulumi.get(self, "key_url")
  
      @key_url.setter
      def key_url(self, value: pulumi.Input[str]):
          pulumi.set(self, "key_url", value)
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> pulumi.Input['SourceVaultArgs']:
          """
          Resource id of the KeyVault containing the key or secret
          """
          return pulumi.get(self, "source_vault")
  
      @source_vault.setter
      def source_vault(self, value: pulumi.Input['SourceVaultArgs']):
          pulumi.set(self, "source_vault", value)
  
  
  @pulumi.input_type
  class KeyVaultAndSecretReferenceArgs:
      def __init__(__self__, *,
                   secret_url: pulumi.Input[str],
                   source_vault: pulumi.Input['SourceVaultArgs']):
          """
          Key Vault Secret Url and vault id of the encryption key 
          :param pulumi.Input[str] secret_url: Url pointing to a key or secret in KeyVault
          :param pulumi.Input['SourceVaultArgs'] 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) -> pulumi.Input[str]:
          """
          Url pointing to a key or secret in KeyVault
          """
          return pulumi.get(self, "secret_url")
  
      @secret_url.setter
      def secret_url(self, value: pulumi.Input[str]):
          pulumi.set(self, "secret_url", value)
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> pulumi.Input['SourceVaultArgs']:
          """
          Resource id of the KeyVault containing the key or secret
          """
          return pulumi.get(self, "source_vault")
  
      @source_vault.setter
      def source_vault(self, value: pulumi.Input['SourceVaultArgs']):
          pulumi.set(self, "source_vault", value)
  
  
  @pulumi.input_type
  class KeyVaultKeyReferenceArgs:
      def __init__(__self__, *,
                   key_url: pulumi.Input[str],
                   source_vault: pulumi.Input['SubResourceArgs']):
          """
          Describes a reference to Key Vault Key
          :param pulumi.Input[str] key_url: The URL referencing a key encryption key in Key Vault.
          :param pulumi.Input['SubResourceArgs'] 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) -> pulumi.Input[str]:
          """
          The URL referencing a key encryption key in Key Vault.
          """
          return pulumi.get(self, "key_url")
  
      @key_url.setter
      def key_url(self, value: pulumi.Input[str]):
          pulumi.set(self, "key_url", value)
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> pulumi.Input['SubResourceArgs']:
          """
          The relative URL of the Key Vault containing the key.
          """
          return pulumi.get(self, "source_vault")
  
      @source_vault.setter
      def source_vault(self, value: pulumi.Input['SubResourceArgs']):
          pulumi.set(self, "source_vault", value)
  
  
  @pulumi.input_type
  class KeyVaultSecretReferenceArgs:
      def __init__(__self__, *,
                   secret_url: pulumi.Input[str],
                   source_vault: pulumi.Input['SubResourceArgs']):
          """
          Describes a reference to Key Vault Secret
          :param pulumi.Input[str] secret_url: The URL referencing a secret in a Key Vault.
          :param pulumi.Input['SubResourceArgs'] 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) -> pulumi.Input[str]:
          """
          The URL referencing a secret in a Key Vault.
          """
          return pulumi.get(self, "secret_url")
  
      @secret_url.setter
      def secret_url(self, value: pulumi.Input[str]):
          pulumi.set(self, "secret_url", value)
  
      @property
      @pulumi.getter(name="sourceVault")
      def source_vault(self) -> pulumi.Input['SubResourceArgs']:
          """
          The relative URL of the Key Vault containing the secret.
          """
          return pulumi.get(self, "source_vault")
  
      @source_vault.setter
      def source_vault(self, value: pulumi.Input['SubResourceArgs']):
          pulumi.set(self, "source_vault", value)
  
  
  @pulumi.input_type
  class LinuxConfigurationArgs:
      def __init__(__self__, *,
                   disable_password_authentication: Optional[pulumi.Input[bool]] = None,
                   provision_vm_agent: Optional[pulumi.Input[bool]] = None,
                   ssh: Optional[pulumi.Input['SshConfigurationArgs']] = 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 pulumi.Input[bool] disable_password_authentication: Specifies whether password authentication should be disabled.
          :param pulumi.Input[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 pulumi.Input['SshConfigurationArgs'] 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 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[pulumi.Input[bool]]:
          """
          Specifies whether password authentication should be disabled.
          """
          return pulumi.get(self, "disable_password_authentication")
  
      @disable_password_authentication.setter
      def disable_password_authentication(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "disable_password_authentication", value)
  
      @property
      @pulumi.getter(name="provisionVMAgent")
      def provision_vm_agent(self) -> Optional[pulumi.Input[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")
  
      @provision_vm_agent.setter
      def provision_vm_agent(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "provision_vm_agent", value)
  
      @property
      @pulumi.getter
      def ssh(self) -> Optional[pulumi.Input['SshConfigurationArgs']]:
          """
          Specifies the ssh key configuration for a Linux OS.
          """
          return pulumi.get(self, "ssh")
  
      @ssh.setter
      def ssh(self, value: Optional[pulumi.Input['SshConfigurationArgs']]):
          pulumi.set(self, "ssh", value)
  
  
  @pulumi.input_type
  class ManagedDiskParametersArgs:
      def __init__(__self__, *,
                   disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
          """
          The parameters of a managed disk.
          :param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
          :param pulumi.Input[str] id: Resource Id
          :param pulumi.Input[Union[str, 'StorageAccountTypes']] 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[pulumi.Input['DiskEncryptionSetParametersArgs']]:
          """
          Specifies the customer managed disk encryption set resource id for the managed disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @disk_encryption_set.setter
      def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
          pulumi.set(self, "disk_encryption_set", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
          """
          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")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
          pulumi.set(self, "storage_account_type", value)
  
  
  @pulumi.input_type
  class NetworkInterfaceReferenceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   primary: Optional[pulumi.Input[bool]] = None):
          """
          Describes a network interface reference.
          :param pulumi.Input[str] id: Resource Id
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      @primary.setter
      def primary(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary", value)
  
  
  @pulumi.input_type
  class NetworkProfileArgs:
      def __init__(__self__, *,
                   network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]] = None):
          """
          Specifies the network interfaces of the virtual machine.
          :param pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]] 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[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]]:
          """
          Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
          """
          return pulumi.get(self, "network_interfaces")
  
      @network_interfaces.setter
      def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceReferenceArgs']]]]):
          pulumi.set(self, "network_interfaces", value)
  
  
  @pulumi.input_type
  class OSDiskArgs:
      def __init__(__self__, *,
                   create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   diff_disk_settings: Optional[pulumi.Input['DiffDiskSettingsArgs']] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   encryption_settings: Optional[pulumi.Input['DiskEncryptionSettingsArgs']] = None,
                   image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
                   managed_disk: Optional[pulumi.Input['ManagedDiskParametersArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   os_type: Optional[pulumi.Input['OperatingSystemTypes']] = None,
                   vhd: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
                   write_accelerator_enabled: Optional[pulumi.Input[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 pulumi.Input[Union[str, 'DiskCreateOptionTypes']] 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 pulumi.Input['CachingTypes'] 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 pulumi.Input['DiffDiskSettingsArgs'] diff_disk_settings: Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
          :param pulumi.Input[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 pulumi.Input['DiskEncryptionSettingsArgs'] encryption_settings: Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          :param pulumi.Input['VirtualHardDiskArgs'] 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 pulumi.Input['ManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
          :param pulumi.Input[str] name: The disk name.
          :param pulumi.Input['OperatingSystemTypes'] 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 pulumi.Input['VirtualHardDiskArgs'] vhd: The virtual hard disk.
          :param pulumi.Input[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) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
          """
          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")
  
      @create_option.setter
      def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
          pulumi.set(self, "create_option", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diffDiskSettings")
      def diff_disk_settings(self) -> Optional[pulumi.Input['DiffDiskSettingsArgs']]:
          """
          Specifies the ephemeral Disk Settings for the operating system disk used by the virtual machine.
          """
          return pulumi.get(self, "diff_disk_settings")
  
      @diff_disk_settings.setter
      def diff_disk_settings(self, value: Optional[pulumi.Input['DiffDiskSettingsArgs']]):
          pulumi.set(self, "diff_disk_settings", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter(name="encryptionSettings")
      def encryption_settings(self) -> Optional[pulumi.Input['DiskEncryptionSettingsArgs']]:
          """
          Specifies the encryption settings for the OS Disk. <br><br> Minimum api-version: 2015-06-15
          """
          return pulumi.get(self, "encryption_settings")
  
      @encryption_settings.setter
      def encryption_settings(self, value: Optional[pulumi.Input['DiskEncryptionSettingsArgs']]):
          pulumi.set(self, "encryption_settings", value)
  
      @property
      @pulumi.getter
      def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
          """
          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")
  
      @image.setter
      def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
          pulumi.set(self, "image", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['ManagedDiskParametersArgs']]:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['ManagedDiskParametersArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> Optional[pulumi.Input['OperatingSystemTypes']]:
          """
          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")
  
      @os_type.setter
      def os_type(self, value: Optional[pulumi.Input['OperatingSystemTypes']]):
          pulumi.set(self, "os_type", value)
  
      @property
      @pulumi.getter
      def vhd(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
          """
          The virtual hard disk.
          """
          return pulumi.get(self, "vhd")
  
      @vhd.setter
      def vhd(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
          pulumi.set(self, "vhd", value)
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      @write_accelerator_enabled.setter
      def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "write_accelerator_enabled", value)
  
  
  @pulumi.input_type
  class OSProfileArgs:
      def __init__(__self__, *,
                   admin_password: Optional[pulumi.Input[str]] = None,
                   admin_username: Optional[pulumi.Input[str]] = None,
                   allow_extension_operations: Optional[pulumi.Input[bool]] = None,
                   computer_name: Optional[pulumi.Input[str]] = None,
                   custom_data: Optional[pulumi.Input[str]] = None,
                   linux_configuration: Optional[pulumi.Input['LinuxConfigurationArgs']] = None,
                   require_guest_provision_signal: Optional[pulumi.Input[bool]] = None,
                   secrets: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]] = None,
                   windows_configuration: Optional[pulumi.Input['WindowsConfigurationArgs']] = None):
          """
          Specifies the operating system settings for the virtual machine. Some of the settings cannot be changed once VM is provisioned.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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://docs.microsoft.com/azure/virtual-machines/custom-data) <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 pulumi.Input['LinuxConfigurationArgs'] 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 pulumi.Input[bool] require_guest_provision_signal: Specifies whether the guest provision signal is required to infer provision success of the virtual machine.
          :param pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]] secrets: Specifies set of certificates that should be installed onto the virtual machine.
          :param pulumi.Input['WindowsConfigurationArgs'] 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[pulumi.Input[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")
  
      @admin_password.setter
      def admin_password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "admin_password", value)
  
      @property
      @pulumi.getter(name="adminUsername")
      def admin_username(self) -> Optional[pulumi.Input[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")
  
      @admin_username.setter
      def admin_username(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "admin_username", value)
  
      @property
      @pulumi.getter(name="allowExtensionOperations")
      def allow_extension_operations(self) -> Optional[pulumi.Input[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")
  
      @allow_extension_operations.setter
      def allow_extension_operations(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_extension_operations", value)
  
      @property
      @pulumi.getter(name="computerName")
      def computer_name(self) -> Optional[pulumi.Input[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")
  
      @computer_name.setter
      def computer_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "computer_name", value)
  
      @property
      @pulumi.getter(name="customData")
      def custom_data(self) -> Optional[pulumi.Input[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://docs.microsoft.com/azure/virtual-machines/custom-data) <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")
  
      @custom_data.setter
      def custom_data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "custom_data", value)
  
      @property
      @pulumi.getter(name="linuxConfiguration")
      def linux_configuration(self) -> Optional[pulumi.Input['LinuxConfigurationArgs']]:
          """
          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")
  
      @linux_configuration.setter
      def linux_configuration(self, value: Optional[pulumi.Input['LinuxConfigurationArgs']]):
          pulumi.set(self, "linux_configuration", value)
  
      @property
      @pulumi.getter(name="requireGuestProvisionSignal")
      def require_guest_provision_signal(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether the guest provision signal is required to infer provision success of the virtual machine.
          """
          return pulumi.get(self, "require_guest_provision_signal")
  
      @require_guest_provision_signal.setter
      def require_guest_provision_signal(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "require_guest_provision_signal", value)
  
      @property
      @pulumi.getter
      def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]:
          """
          Specifies set of certificates that should be installed onto the virtual machine.
          """
          return pulumi.get(self, "secrets")
  
      @secrets.setter
      def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]):
          pulumi.set(self, "secrets", value)
  
      @property
      @pulumi.getter(name="windowsConfiguration")
      def windows_configuration(self) -> Optional[pulumi.Input['WindowsConfigurationArgs']]:
          """
          Specifies Windows operating system settings on the virtual machine.
          """
          return pulumi.get(self, "windows_configuration")
  
      @windows_configuration.setter
      def windows_configuration(self, value: Optional[pulumi.Input['WindowsConfigurationArgs']]):
          pulumi.set(self, "windows_configuration", value)
  
  
  @pulumi.input_type
  class PlanArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[str]] = None,
                   product: Optional[pulumi.Input[str]] = None,
                   promotion_code: Optional[pulumi.Input[str]] = None,
                   publisher: Optional[pulumi.Input[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 pulumi.Input[str] name: The plan ID.
          :param pulumi.Input[str] product: Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
          :param pulumi.Input[str] promotion_code: The promotion code.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          The plan ID.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def product(self) -> Optional[pulumi.Input[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")
  
      @product.setter
      def product(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "product", value)
  
      @property
      @pulumi.getter(name="promotionCode")
      def promotion_code(self) -> Optional[pulumi.Input[str]]:
          """
          The promotion code.
          """
          return pulumi.get(self, "promotion_code")
  
      @promotion_code.setter
      def promotion_code(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "promotion_code", value)
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[pulumi.Input[str]]:
          """
          The publisher ID.
          """
          return pulumi.get(self, "publisher")
  
      @publisher.setter
      def publisher(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "publisher", value)
  
  
  @pulumi.input_type
  class RecommendedMachineConfigurationArgs:
      def __init__(__self__, *,
                   memory: Optional[pulumi.Input['ResourceRangeArgs']] = None,
                   v_cpus: Optional[pulumi.Input['ResourceRangeArgs']] = None):
          """
          The properties describe the recommended machine configuration for this Image Definition. These properties are updatable.
          :param pulumi.Input['ResourceRangeArgs'] memory: Describes the resource range.
          :param pulumi.Input['ResourceRangeArgs'] 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[pulumi.Input['ResourceRangeArgs']]:
          """
          Describes the resource range.
          """
          return pulumi.get(self, "memory")
  
      @memory.setter
      def memory(self, value: Optional[pulumi.Input['ResourceRangeArgs']]):
          pulumi.set(self, "memory", value)
  
      @property
      @pulumi.getter(name="vCPUs")
      def v_cpus(self) -> Optional[pulumi.Input['ResourceRangeArgs']]:
          """
          Describes the resource range.
          """
          return pulumi.get(self, "v_cpus")
  
      @v_cpus.setter
      def v_cpus(self, value: Optional[pulumi.Input['ResourceRangeArgs']]):
          pulumi.set(self, "v_cpus", value)
  
  
  @pulumi.input_type
  class ResourceRangeArgs:
      def __init__(__self__, *,
                   max: Optional[pulumi.Input[int]] = None,
                   min: Optional[pulumi.Input[int]] = None):
          """
          Describes the resource range.
          :param pulumi.Input[int] max: The maximum number of the resource.
          :param pulumi.Input[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[pulumi.Input[int]]:
          """
          The maximum number of the resource.
          """
          return pulumi.get(self, "max")
  
      @max.setter
      def max(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max", value)
  
      @property
      @pulumi.getter
      def min(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum number of the resource.
          """
          return pulumi.get(self, "min")
  
      @min.setter
      def min(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min", value)
  
  
  @pulumi.input_type
  class RollingUpgradePolicyArgs:
      def __init__(__self__, *,
                   max_batch_instance_percent: Optional[pulumi.Input[int]] = None,
                   max_unhealthy_instance_percent: Optional[pulumi.Input[int]] = None,
                   max_unhealthy_upgraded_instance_percent: Optional[pulumi.Input[int]] = None,
                   pause_time_between_batches: Optional[pulumi.Input[str]] = None):
          """
          The configuration parameters used while performing a rolling upgrade.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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).
          """
          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)
  
      @property
      @pulumi.getter(name="maxBatchInstancePercent")
      def max_batch_instance_percent(self) -> Optional[pulumi.Input[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")
  
      @max_batch_instance_percent.setter
      def max_batch_instance_percent(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_batch_instance_percent", value)
  
      @property
      @pulumi.getter(name="maxUnhealthyInstancePercent")
      def max_unhealthy_instance_percent(self) -> Optional[pulumi.Input[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")
  
      @max_unhealthy_instance_percent.setter
      def max_unhealthy_instance_percent(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_unhealthy_instance_percent", value)
  
      @property
      @pulumi.getter(name="maxUnhealthyUpgradedInstancePercent")
      def max_unhealthy_upgraded_instance_percent(self) -> Optional[pulumi.Input[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")
  
      @max_unhealthy_upgraded_instance_percent.setter
      def max_unhealthy_upgraded_instance_percent(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_unhealthy_upgraded_instance_percent", value)
  
      @property
      @pulumi.getter(name="pauseTimeBetweenBatches")
      def pause_time_between_batches(self) -> Optional[pulumi.Input[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")
  
      @pause_time_between_batches.setter
      def pause_time_between_batches(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "pause_time_between_batches", value)
  
  
  @pulumi.input_type
  class ScaleInPolicyArgs:
      def __init__(__self__, *,
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]] = None):
          """
          Describes a scale-in policy for a virtual machine scale set.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]] 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[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]]:
          """
          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")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VirtualMachineScaleSetScaleInRules']]]]]):
          pulumi.set(self, "rules", value)
  
  
  @pulumi.input_type
  class ScheduledEventsProfileArgs:
      def __init__(__self__, *,
                   terminate_notification_profile: Optional[pulumi.Input['TerminateNotificationProfileArgs']] = None):
          """
          :param pulumi.Input['TerminateNotificationProfileArgs'] 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[pulumi.Input['TerminateNotificationProfileArgs']]:
          """
          Specifies Terminate Scheduled Event related configurations.
          """
          return pulumi.get(self, "terminate_notification_profile")
  
      @terminate_notification_profile.setter
      def terminate_notification_profile(self, value: Optional[pulumi.Input['TerminateNotificationProfileArgs']]):
          pulumi.set(self, "terminate_notification_profile", value)
  
  
  @pulumi.input_type
  class SkuArgs:
      def __init__(__self__, *,
                   capacity: Optional[pulumi.Input[float]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   tier: Optional[pulumi.Input[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 pulumi.Input[float] capacity: Specifies the number of virtual machines in the scale set.
          :param pulumi.Input[str] name: The sku name.
          :param pulumi.Input[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[pulumi.Input[float]]:
          """
          Specifies the number of virtual machines in the scale set.
          """
          return pulumi.get(self, "capacity")
  
      @capacity.setter
      def capacity(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "capacity", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def tier(self) -> Optional[pulumi.Input[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")
  
      @tier.setter
      def tier(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "tier", value)
  
  
  @pulumi.input_type
  class SnapshotSkuArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[Union[str, 'SnapshotStorageAccountTypes']]] = None):
          """
          The snapshots sku name. Can be Standard_LRS, Premium_LRS, or Standard_ZRS.
          :param pulumi.Input[Union[str, 'SnapshotStorageAccountTypes']] name: The sku name.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'SnapshotStorageAccountTypes']]]:
          """
          The sku name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'SnapshotStorageAccountTypes']]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class SourceVaultArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[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 pulumi.Input[str] id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class SshConfigurationArgs:
      def __init__(__self__, *,
                   public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]] = None):
          """
          SSH configuration for Linux based VMs running on Azure
          :param pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]] 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[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]]:
          """
          The list of SSH public keys used to authenticate with linux based VMs.
          """
          return pulumi.get(self, "public_keys")
  
      @public_keys.setter
      def public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SshPublicKeyArgs']]]]):
          pulumi.set(self, "public_keys", value)
  
  
  @pulumi.input_type
  class SshPublicKeyArgs:
      def __init__(__self__, *,
                   key_data: Optional[pulumi.Input[str]] = None,
                   path: Optional[pulumi.Input[str]] = None):
          """
          Contains information about SSH certificate public key and the path on the Linux VM where the public key is placed.
          :param pulumi.Input[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/azure/virtual-machines/virtual-machines-linux-mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          :param pulumi.Input[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[pulumi.Input[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/azure/virtual-machines/virtual-machines-linux-mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
          """
          return pulumi.get(self, "key_data")
  
      @key_data.setter
      def key_data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key_data", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input[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")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class StorageProfileArgs:
      def __init__(__self__, *,
                   data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]] = None,
                   image_reference: Optional[pulumi.Input['ImageReferenceArgs']] = None,
                   os_disk: Optional[pulumi.Input['OSDiskArgs']] = None):
          """
          Specifies the storage settings for the virtual machine disks.
          :param pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]] 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 pulumi.Input['ImageReferenceArgs'] 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 pulumi.Input['OSDiskArgs'] 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[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]]:
          """
          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")
  
      @data_disks.setter
      def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataDiskArgs']]]]):
          pulumi.set(self, "data_disks", value)
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional[pulumi.Input['ImageReferenceArgs']]:
          """
          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")
  
      @image_reference.setter
      def image_reference(self, value: Optional[pulumi.Input['ImageReferenceArgs']]):
          pulumi.set(self, "image_reference", value)
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional[pulumi.Input['OSDiskArgs']]:
          """
          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")
  
      @os_disk.setter
      def os_disk(self, value: Optional[pulumi.Input['OSDiskArgs']]):
          pulumi.set(self, "os_disk", value)
  
  
  @pulumi.input_type
  class SubResourceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] id: Resource Id
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class TargetRegionArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   regional_replica_count: Optional[pulumi.Input[int]] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountType']]] = None):
          """
          Describes the target region information.
          :param pulumi.Input[str] name: The name of the region.
          :param pulumi.Input[int] regional_replica_count: The number of replicas of the Image Version to be created per region. This property is updatable.
          :param pulumi.Input[Union[str, 'StorageAccountType']] 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 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) -> pulumi.Input[str]:
          """
          The name of the region.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="regionalReplicaCount")
      def regional_replica_count(self) -> Optional[pulumi.Input[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")
  
      @regional_replica_count.setter
      def regional_replica_count(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "regional_replica_count", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountType']]]:
          """
          Specifies the storage account type to be used to store the image. This property is not updatable.
          """
          return pulumi.get(self, "storage_account_type")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountType']]]):
          pulumi.set(self, "storage_account_type", value)
  
  
  @pulumi.input_type
  class TerminateNotificationProfileArgs:
      def __init__(__self__, *,
                   enable: Optional[pulumi.Input[bool]] = None,
                   not_before_timeout: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] enable: Specifies whether the Terminate Scheduled event is enabled or disabled.
          :param pulumi.Input[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[pulumi.Input[bool]]:
          """
          Specifies whether the Terminate Scheduled event is enabled or disabled.
          """
          return pulumi.get(self, "enable")
  
      @enable.setter
      def enable(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable", value)
  
      @property
      @pulumi.getter(name="notBeforeTimeout")
      def not_before_timeout(self) -> Optional[pulumi.Input[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")
  
      @not_before_timeout.setter
      def not_before_timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "not_before_timeout", value)
  
  
  @pulumi.input_type
  class UpgradePolicyArgs:
      def __init__(__self__, *,
                   automatic_os_upgrade_policy: Optional[pulumi.Input['AutomaticOSUpgradePolicyArgs']] = None,
                   mode: Optional[pulumi.Input['UpgradeMode']] = None,
                   rolling_upgrade_policy: Optional[pulumi.Input['RollingUpgradePolicyArgs']] = None):
          """
          Describes an upgrade policy - automatic, manual, or rolling.
          :param pulumi.Input['AutomaticOSUpgradePolicyArgs'] automatic_os_upgrade_policy: Configuration parameters used for performing automatic OS Upgrade.
          :param pulumi.Input['UpgradeMode'] 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 pulumi.Input['RollingUpgradePolicyArgs'] 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[pulumi.Input['AutomaticOSUpgradePolicyArgs']]:
          """
          Configuration parameters used for performing automatic OS Upgrade.
          """
          return pulumi.get(self, "automatic_os_upgrade_policy")
  
      @automatic_os_upgrade_policy.setter
      def automatic_os_upgrade_policy(self, value: Optional[pulumi.Input['AutomaticOSUpgradePolicyArgs']]):
          pulumi.set(self, "automatic_os_upgrade_policy", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input['UpgradeMode']]:
          """
          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")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input['UpgradeMode']]):
          pulumi.set(self, "mode", value)
  
      @property
      @pulumi.getter(name="rollingUpgradePolicy")
      def rolling_upgrade_policy(self) -> Optional[pulumi.Input['RollingUpgradePolicyArgs']]:
          """
          The configuration parameters used while performing a rolling upgrade.
          """
          return pulumi.get(self, "rolling_upgrade_policy")
  
      @rolling_upgrade_policy.setter
      def rolling_upgrade_policy(self, value: Optional[pulumi.Input['RollingUpgradePolicyArgs']]):
          pulumi.set(self, "rolling_upgrade_policy", value)
  
  
  @pulumi.input_type
  class UserArtifactManageArgs:
      def __init__(__self__, *,
                   install: pulumi.Input[str],
                   remove: pulumi.Input[str],
                   update: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] install: Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
          :param pulumi.Input[str] remove: Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
          :param pulumi.Input[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) -> pulumi.Input[str]:
          """
          Required. The path and arguments to install the gallery application. This is limited to 4096 characters.
          """
          return pulumi.get(self, "install")
  
      @install.setter
      def install(self, value: pulumi.Input[str]):
          pulumi.set(self, "install", value)
  
      @property
      @pulumi.getter
      def remove(self) -> pulumi.Input[str]:
          """
          Required. The path and arguments to remove the gallery application. This is limited to 4096 characters.
          """
          return pulumi.get(self, "remove")
  
      @remove.setter
      def remove(self, value: pulumi.Input[str]):
          pulumi.set(self, "remove", value)
  
      @property
      @pulumi.getter
      def update(self) -> Optional[pulumi.Input[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")
  
      @update.setter
      def update(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "update", value)
  
  
  @pulumi.input_type
  class UserArtifactSourceArgs:
      def __init__(__self__, *,
                   media_link: pulumi.Input[str],
                   default_configuration_link: Optional[pulumi.Input[str]] = None):
          """
          The source image from which the Image Version is going to be created.
          :param pulumi.Input[str] media_link: Required. The mediaLink of the artifact, must be a readable storage page blob.
          :param pulumi.Input[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) -> pulumi.Input[str]:
          """
          Required. The mediaLink of the artifact, must be a readable storage page blob.
          """
          return pulumi.get(self, "media_link")
  
      @media_link.setter
      def media_link(self, value: pulumi.Input[str]):
          pulumi.set(self, "media_link", value)
  
      @property
      @pulumi.getter(name="defaultConfigurationLink")
      def default_configuration_link(self) -> Optional[pulumi.Input[str]]:
          """
          Optional. The defaultConfigurationLink of the artifact, must be a readable storage page blob.
          """
          return pulumi.get(self, "default_configuration_link")
  
      @default_configuration_link.setter
      def default_configuration_link(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "default_configuration_link", value)
  
  
  @pulumi.input_type
  class VaultCertificateArgs:
      def __init__(__self__, *,
                   certificate_store: Optional[pulumi.Input[str]] = None,
                   certificate_url: Optional[pulumi.Input[str]] = None):
          """
          Describes a single certificate reference in a Key Vault, and where the certificate should reside on the VM.
          :param pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")
  
      @certificate_store.setter
      def certificate_store(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "certificate_store", value)
  
      @property
      @pulumi.getter(name="certificateUrl")
      def certificate_url(self) -> Optional[pulumi.Input[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")
  
      @certificate_url.setter
      def certificate_url(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "certificate_url", value)
  
  
  @pulumi.input_type
  class VaultSecretGroupArgs:
      def __init__(__self__, *,
                   source_vault: Optional[pulumi.Input['SubResourceArgs']] = None,
                   vault_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]] = None):
          """
          Describes a set of certificates which are all in the same Key Vault.
          :param pulumi.Input['SubResourceArgs'] source_vault: The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
          :param pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]] 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[pulumi.Input['SubResourceArgs']]:
          """
          The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
          """
          return pulumi.get(self, "source_vault")
  
      @source_vault.setter
      def source_vault(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "source_vault", value)
  
      @property
      @pulumi.getter(name="vaultCertificates")
      def vault_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]]:
          """
          The list of key vault references in SourceVault which contain certificates.
          """
          return pulumi.get(self, "vault_certificates")
  
      @vault_certificates.setter
      def vault_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultCertificateArgs']]]]):
          pulumi.set(self, "vault_certificates", value)
  
  
  @pulumi.input_type
  class VirtualHardDiskArgs:
      def __init__(__self__, *,
                   uri: Optional[pulumi.Input[str]] = None):
          """
          Describes the uri of a disk.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          Specifies the virtual hard disk's uri.
          """
          return pulumi.get(self, "uri")
  
      @uri.setter
      def uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "uri", value)
  
  
  @pulumi.input_type
  class VirtualMachineExtensionInstanceViewArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[str]] = None,
                   statuses: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]] = None,
                   substatuses: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   type_handler_version: Optional[pulumi.Input[str]] = None):
          """
          The instance view of a virtual machine extension.
          :param pulumi.Input[str] name: The virtual machine extension name.
          :param pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]] statuses: The resource status information.
          :param pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]] substatuses: The resource status information.
          :param pulumi.Input[str] type: Specifies the type of the extension; an example is "CustomScriptExtension".
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          The virtual machine extension name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]:
          """
          The resource status information.
          """
          return pulumi.get(self, "statuses")
  
      @statuses.setter
      def statuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]):
          pulumi.set(self, "statuses", value)
  
      @property
      @pulumi.getter
      def substatuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]:
          """
          The resource status information.
          """
          return pulumi.get(self, "substatuses")
  
      @substatuses.setter
      def substatuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceViewStatusArgs']]]]):
          pulumi.set(self, "substatuses", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the type of the extension; an example is "CustomScriptExtension".
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      @type_handler_version.setter
      def type_handler_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type_handler_version", value)
  
  
  @pulumi.input_type
  class VirtualMachineIdentityArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input['ResourceIdentityType']] = None,
                   user_assigned_identities: Optional[pulumi.Input[Mapping[str, Any]]] = None):
          """
          Identity for the virtual machine.
          :param pulumi.Input['ResourceIdentityType'] 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 pulumi.Input[Mapping[str, Any]] 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}'.
          """
          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
      def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
          """
          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")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
          """
          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")
  
      @user_assigned_identities.setter
      def user_assigned_identities(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
          pulumi.set(self, "user_assigned_identities", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetDataDiskArgs:
      def __init__(__self__, *,
                   create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
                   lun: pulumi.Input[int],
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   disk_iops_read_write: Optional[pulumi.Input[float]] = None,
                   disk_m_bps_read_write: Optional[pulumi.Input[float]] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   managed_disk: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
          """
          Describes a virtual machine scale set data disk.
          :param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] create_option: The create option.
          :param pulumi.Input[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 pulumi.Input['CachingTypes'] 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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
          :param pulumi.Input[str] name: The disk name.
          :param pulumi.Input[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) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
          """
          The create option.
          """
          return pulumi.get(self, "create_option")
  
      @create_option.setter
      def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
          pulumi.set(self, "create_option", value)
  
      @property
      @pulumi.getter
      def lun(self) -> pulumi.Input[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")
  
      @lun.setter
      def lun(self, value: pulumi.Input[int]):
          pulumi.set(self, "lun", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diskIOPSReadWrite")
      def disk_iops_read_write(self) -> Optional[pulumi.Input[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")
  
      @disk_iops_read_write.setter
      def disk_iops_read_write(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "disk_iops_read_write", value)
  
      @property
      @pulumi.getter(name="diskMBpsReadWrite")
      def disk_m_bps_read_write(self) -> Optional[pulumi.Input[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")
  
      @disk_m_bps_read_write.setter
      def disk_m_bps_read_write(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "disk_m_bps_read_write", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      @write_accelerator_enabled.setter
      def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "write_accelerator_enabled", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetExtensionArgs:
      def __init__(__self__, *,
                   auto_upgrade_minor_version: Optional[pulumi.Input[bool]] = None,
                   force_update_tag: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protected_settings: Optional[Any] = None,
                   provision_after_extensions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   publisher: Optional[pulumi.Input[str]] = None,
                   settings: Optional[Any] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   type_handler_version: Optional[pulumi.Input[str]] = None):
          """
          Describes a Virtual Machine Scale Set Extension.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] provision_after_extensions: Collection of extension names after which this extension needs to be provisioned.
          :param pulumi.Input[str] publisher: The name of the extension handler publisher.
          :param Any settings: Json formatted public settings for the extension.
          :param pulumi.Input[str] type: Specifies the type of the extension; an example is "CustomScriptExtension".
          :param pulumi.Input[str] type_handler_version: Specifies the version of the script handler.
          """
          if auto_upgrade_minor_version is not None:
              pulumi.set(__self__, "auto_upgrade_minor_version", auto_upgrade_minor_version)
          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 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(name="autoUpgradeMinorVersion")
      def auto_upgrade_minor_version(self) -> Optional[pulumi.Input[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")
  
      @auto_upgrade_minor_version.setter
      def auto_upgrade_minor_version(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_upgrade_minor_version", value)
  
      @property
      @pulumi.getter(name="forceUpdateTag")
      def force_update_tag(self) -> Optional[pulumi.Input[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")
  
      @force_update_tag.setter
      def force_update_tag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "force_update_tag", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the extension.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @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")
  
      @protected_settings.setter
      def protected_settings(self, value: Optional[Any]):
          pulumi.set(self, "protected_settings", value)
  
      @property
      @pulumi.getter(name="provisionAfterExtensions")
      def provision_after_extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Collection of extension names after which this extension needs to be provisioned.
          """
          return pulumi.get(self, "provision_after_extensions")
  
      @provision_after_extensions.setter
      def provision_after_extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "provision_after_extensions", value)
  
      @property
      @pulumi.getter
      def publisher(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the extension handler publisher.
          """
          return pulumi.get(self, "publisher")
  
      @publisher.setter
      def publisher(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "publisher", value)
  
      @property
      @pulumi.getter
      def settings(self) -> Optional[Any]:
          """
          Json formatted public settings for the extension.
          """
          return pulumi.get(self, "settings")
  
      @settings.setter
      def settings(self, value: Optional[Any]):
          pulumi.set(self, "settings", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the type of the extension; an example is "CustomScriptExtension".
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="typeHandlerVersion")
      def type_handler_version(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the version of the script handler.
          """
          return pulumi.get(self, "type_handler_version")
  
      @type_handler_version.setter
      def type_handler_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type_handler_version", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetExtensionProfileArgs:
      def __init__(__self__, *,
                   extensions: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]] = None):
          """
          Describes a virtual machine scale set extension profile.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]] extensions: The virtual machine scale set child extension resources.
          """
          if extensions is not None:
              pulumi.set(__self__, "extensions", extensions)
  
      @property
      @pulumi.getter
      def extensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]]:
          """
          The virtual machine scale set child extension resources.
          """
          return pulumi.get(self, "extensions")
  
      @extensions.setter
      def extensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetExtensionArgs']]]]):
          pulumi.set(self, "extensions", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetIPConfigurationArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   application_gateway_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   load_balancer_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   load_balancer_inbound_nat_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   primary: Optional[pulumi.Input[bool]] = None,
                   private_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
                   public_ip_address_configuration: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']] = None,
                   subnet: Optional[pulumi.Input['ApiEntityReferenceArgs']] = None):
          """
          Describes a virtual machine scale set network profile's IP configuration.
          :param pulumi.Input[str] name: The IP configuration name.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] 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 pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] application_security_groups: Specifies an array of references to application security group.
          :param pulumi.Input[str] id: Resource Id
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] 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 load balancer.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] 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 load balancer
          :param pulumi.Input[bool] primary: Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          :param pulumi.Input[Union[str, 'IPVersion']] 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 pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs'] public_ip_address_configuration: The publicIPAddressConfiguration.
          :param pulumi.Input['ApiEntityReferenceArgs'] 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) -> pulumi.Input[str]:
          """
          The IP configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="applicationGatewayBackendAddressPools")
      def application_gateway_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          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")
  
      @application_gateway_backend_address_pools.setter
      def application_gateway_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "application_gateway_backend_address_pools", value)
  
      @property
      @pulumi.getter(name="applicationSecurityGroups")
      def application_security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Specifies an array of references to application security group.
          """
          return pulumi.get(self, "application_security_groups")
  
      @application_security_groups.setter
      def application_security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "application_security_groups", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="loadBalancerBackendAddressPools")
      def load_balancer_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          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 load balancer.
          """
          return pulumi.get(self, "load_balancer_backend_address_pools")
  
      @load_balancer_backend_address_pools.setter
      def load_balancer_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "load_balancer_backend_address_pools", value)
  
      @property
      @pulumi.getter(name="loadBalancerInboundNatPools")
      def load_balancer_inbound_nat_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          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 load balancer
          """
          return pulumi.get(self, "load_balancer_inbound_nat_pools")
  
      @load_balancer_inbound_nat_pools.setter
      def load_balancer_inbound_nat_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "load_balancer_inbound_nat_pools", value)
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      @primary.setter
      def primary(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary", value)
  
      @property
      @pulumi.getter(name="privateIPAddressVersion")
      def private_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
          """
          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")
  
      @private_ip_address_version.setter
      def private_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
          pulumi.set(self, "private_ip_address_version", value)
  
      @property
      @pulumi.getter(name="publicIPAddressConfiguration")
      def public_ip_address_configuration(self) -> Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']]:
          """
          The publicIPAddressConfiguration.
          """
          return pulumi.get(self, "public_ip_address_configuration")
  
      @public_ip_address_configuration.setter
      def public_ip_address_configuration(self, value: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationArgs']]):
          pulumi.set(self, "public_ip_address_configuration", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['ApiEntityReferenceArgs']]:
          """
          Specifies the identifier of the subnet.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['ApiEntityReferenceArgs']]):
          pulumi.set(self, "subnet", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetIdentityArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input['ResourceIdentityType']] = None,
                   user_assigned_identities: Optional[pulumi.Input[Mapping[str, Any]]] = None):
          """
          Identity for the virtual machine scale set.
          :param pulumi.Input['ResourceIdentityType'] 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 pulumi.Input[Mapping[str, Any]] 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}'.
          """
          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
      def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
          """
          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")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
          """
          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")
  
      @user_assigned_identities.setter
      def user_assigned_identities(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
          pulumi.set(self, "user_assigned_identities", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetIpTagArgs:
      def __init__(__self__, *,
                   ip_tag_type: Optional[pulumi.Input[str]] = None,
                   tag: Optional[pulumi.Input[str]] = None):
          """
          Contains the IP tag associated with the public IP address.
          :param pulumi.Input[str] ip_tag_type: IP tag type. Example: FirstPartyUsage.
          :param pulumi.Input[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[pulumi.Input[str]]:
          """
          IP tag type. Example: FirstPartyUsage.
          """
          return pulumi.get(self, "ip_tag_type")
  
      @ip_tag_type.setter
      def ip_tag_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_tag_type", value)
  
      @property
      @pulumi.getter
      def tag(self) -> Optional[pulumi.Input[str]]:
          """
          IP tag associated with the public IP. Example: SQL, Storage etc.
          """
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "tag", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetManagedDiskParametersArgs:
      def __init__(__self__, *,
                   disk_encryption_set: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']] = None,
                   storage_account_type: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]] = None):
          """
          Describes the parameters of a ScaleSet managed disk.
          :param pulumi.Input['DiskEncryptionSetParametersArgs'] disk_encryption_set: Specifies the customer managed disk encryption set resource id for the managed disk.
          :param pulumi.Input[Union[str, 'StorageAccountTypes']] storage_account_type: Specifies the storage account type for the managed disk. Managed OS disk storage account type can only be set when you create the scale set. 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[pulumi.Input['DiskEncryptionSetParametersArgs']]:
          """
          Specifies the customer managed disk encryption set resource id for the managed disk.
          """
          return pulumi.get(self, "disk_encryption_set")
  
      @disk_encryption_set.setter
      def disk_encryption_set(self, value: Optional[pulumi.Input['DiskEncryptionSetParametersArgs']]):
          pulumi.set(self, "disk_encryption_set", value)
  
      @property
      @pulumi.getter(name="storageAccountType")
      def storage_account_type(self) -> Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]:
          """
          Specifies the storage account type for the managed disk. Managed OS disk storage account type can only be set when you create the scale set. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
          """
          return pulumi.get(self, "storage_account_type")
  
      @storage_account_type.setter
      def storage_account_type(self, value: Optional[pulumi.Input[Union[str, 'StorageAccountTypes']]]):
          pulumi.set(self, "storage_account_type", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetNetworkConfigurationArgs:
      def __init__(__self__, *,
                   ip_configurations: pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]],
                   name: pulumi.Input[str],
                   dns_settings: Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']] = None,
                   enable_accelerated_networking: Optional[pulumi.Input[bool]] = None,
                   enable_ip_forwarding: Optional[pulumi.Input[bool]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   network_security_group: Optional[pulumi.Input['SubResourceArgs']] = None,
                   primary: Optional[pulumi.Input[bool]] = None):
          """
          Describes a virtual machine scale set network profile's network configurations.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]] ip_configurations: Specifies the IP configurations of the network interface.
          :param pulumi.Input[str] name: The network configuration name.
          :param pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs'] dns_settings: The dns settings to be applied on the network interfaces.
          :param pulumi.Input[bool] enable_accelerated_networking: Specifies whether the network interface is accelerated networking-enabled.
          :param pulumi.Input[bool] enable_ip_forwarding: Whether IP forwarding enabled on this NIC.
          :param pulumi.Input[str] id: Resource Id
          :param pulumi.Input['SubResourceArgs'] network_security_group: The network security group.
          :param pulumi.Input[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_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) -> pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]]:
          """
          Specifies the IP configurations of the network interface.
          """
          return pulumi.get(self, "ip_configurations")
  
      @ip_configurations.setter
      def ip_configurations(self, value: pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIPConfigurationArgs']]]):
          pulumi.set(self, "ip_configurations", value)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The network configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="dnsSettings")
      def dns_settings(self) -> Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']]:
          """
          The dns settings to be applied on the network interfaces.
          """
          return pulumi.get(self, "dns_settings")
  
      @dns_settings.setter
      def dns_settings(self, value: Optional[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs']]):
          pulumi.set(self, "dns_settings", value)
  
      @property
      @pulumi.getter(name="enableAcceleratedNetworking")
      def enable_accelerated_networking(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether the network interface is accelerated networking-enabled.
          """
          return pulumi.get(self, "enable_accelerated_networking")
  
      @enable_accelerated_networking.setter
      def enable_accelerated_networking(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_accelerated_networking", value)
  
      @property
      @pulumi.getter(name="enableIPForwarding")
      def enable_ip_forwarding(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether IP forwarding enabled on this NIC.
          """
          return pulumi.get(self, "enable_ip_forwarding")
  
      @enable_ip_forwarding.setter
      def enable_ip_forwarding(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_ip_forwarding", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource Id
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="networkSecurityGroup")
      def network_security_group(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The network security group.
          """
          return pulumi.get(self, "network_security_group")
  
      @network_security_group.setter
      def network_security_group(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "network_security_group", value)
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies the primary network interface in case the virtual machine has more than 1 network interface.
          """
          return pulumi.get(self, "primary")
  
      @primary.setter
      def primary(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetNetworkConfigurationDnsSettingsArgs:
      def __init__(__self__, *,
                   dns_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Describes a virtual machines scale sets network configuration's DNS settings.
          :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of DNS servers IP addresses
          """
          return pulumi.get(self, "dns_servers")
  
      @dns_servers.setter
      def dns_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "dns_servers", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetNetworkProfileArgs:
      def __init__(__self__, *,
                   health_probe: Optional[pulumi.Input['ApiEntityReferenceArgs']] = None,
                   network_interface_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]] = None):
          """
          Describes a virtual machine scale set network profile.
          :param pulumi.Input['ApiEntityReferenceArgs'] 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 pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]] 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[pulumi.Input['ApiEntityReferenceArgs']]:
          """
          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")
  
      @health_probe.setter
      def health_probe(self, value: Optional[pulumi.Input['ApiEntityReferenceArgs']]):
          pulumi.set(self, "health_probe", value)
  
      @property
      @pulumi.getter(name="networkInterfaceConfigurations")
      def network_interface_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]:
          """
          The list of network configurations.
          """
          return pulumi.get(self, "network_interface_configurations")
  
      @network_interface_configurations.setter
      def network_interface_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]):
          pulumi.set(self, "network_interface_configurations", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetOSDiskArgs:
      def __init__(__self__, *,
                   create_option: pulumi.Input[Union[str, 'DiskCreateOptionTypes']],
                   caching: Optional[pulumi.Input['CachingTypes']] = None,
                   diff_disk_settings: Optional[pulumi.Input['DiffDiskSettingsArgs']] = None,
                   disk_size_gb: Optional[pulumi.Input[int]] = None,
                   image: Optional[pulumi.Input['VirtualHardDiskArgs']] = None,
                   managed_disk: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   os_type: Optional[pulumi.Input['OperatingSystemTypes']] = None,
                   vhd_containers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   write_accelerator_enabled: Optional[pulumi.Input[bool]] = None):
          """
          Describes a virtual machine scale set operating system disk.
          :param pulumi.Input[Union[str, 'DiskCreateOptionTypes']] 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 pulumi.Input['CachingTypes'] 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 pulumi.Input['DiffDiskSettingsArgs'] diff_disk_settings: Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
          :param pulumi.Input[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 pulumi.Input['VirtualHardDiskArgs'] image: Specifies information about the unmanaged user image to base the scale set on.
          :param pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs'] managed_disk: The managed disk parameters.
          :param pulumi.Input[str] name: The disk name.
          :param pulumi.Input['OperatingSystemTypes'] 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 pulumi.Input[Sequence[pulumi.Input[str]]] vhd_containers: Specifies the container urls that are used to store operating system disks for the scale set.
          :param pulumi.Input[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) -> pulumi.Input[Union[str, 'DiskCreateOptionTypes']]:
          """
          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")
  
      @create_option.setter
      def create_option(self, value: pulumi.Input[Union[str, 'DiskCreateOptionTypes']]):
          pulumi.set(self, "create_option", value)
  
      @property
      @pulumi.getter
      def caching(self) -> Optional[pulumi.Input['CachingTypes']]:
          """
          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")
  
      @caching.setter
      def caching(self, value: Optional[pulumi.Input['CachingTypes']]):
          pulumi.set(self, "caching", value)
  
      @property
      @pulumi.getter(name="diffDiskSettings")
      def diff_disk_settings(self) -> Optional[pulumi.Input['DiffDiskSettingsArgs']]:
          """
          Specifies the ephemeral disk Settings for the operating system disk used by the virtual machine scale set.
          """
          return pulumi.get(self, "diff_disk_settings")
  
      @diff_disk_settings.setter
      def diff_disk_settings(self, value: Optional[pulumi.Input['DiffDiskSettingsArgs']]):
          pulumi.set(self, "diff_disk_settings", value)
  
      @property
      @pulumi.getter(name="diskSizeGB")
      def disk_size_gb(self) -> Optional[pulumi.Input[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")
  
      @disk_size_gb.setter
      def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size_gb", value)
  
      @property
      @pulumi.getter
      def image(self) -> Optional[pulumi.Input['VirtualHardDiskArgs']]:
          """
          Specifies information about the unmanaged user image to base the scale set on.
          """
          return pulumi.get(self, "image")
  
      @image.setter
      def image(self, value: Optional[pulumi.Input['VirtualHardDiskArgs']]):
          pulumi.set(self, "image", value)
  
      @property
      @pulumi.getter(name="managedDisk")
      def managed_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]:
          """
          The managed disk parameters.
          """
          return pulumi.get(self, "managed_disk")
  
      @managed_disk.setter
      def managed_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetManagedDiskParametersArgs']]):
          pulumi.set(self, "managed_disk", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The disk name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="osType")
      def os_type(self) -> Optional[pulumi.Input['OperatingSystemTypes']]:
          """
          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")
  
      @os_type.setter
      def os_type(self, value: Optional[pulumi.Input['OperatingSystemTypes']]):
          pulumi.set(self, "os_type", value)
  
      @property
      @pulumi.getter(name="vhdContainers")
      def vhd_containers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Specifies the container urls that are used to store operating system disks for the scale set.
          """
          return pulumi.get(self, "vhd_containers")
  
      @vhd_containers.setter
      def vhd_containers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "vhd_containers", value)
  
      @property
      @pulumi.getter(name="writeAcceleratorEnabled")
      def write_accelerator_enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies whether writeAccelerator should be enabled or disabled on the disk.
          """
          return pulumi.get(self, "write_accelerator_enabled")
  
      @write_accelerator_enabled.setter
      def write_accelerator_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "write_accelerator_enabled", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetOSProfileArgs:
      def __init__(__self__, *,
                   admin_password: Optional[pulumi.Input[str]] = None,
                   admin_username: Optional[pulumi.Input[str]] = None,
                   computer_name_prefix: Optional[pulumi.Input[str]] = None,
                   custom_data: Optional[pulumi.Input[str]] = None,
                   linux_configuration: Optional[pulumi.Input['LinuxConfigurationArgs']] = None,
                   secrets: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]] = None,
                   windows_configuration: Optional[pulumi.Input['WindowsConfigurationArgs']] = None):
          """
          Describes a virtual machine scale set OS profile.
          :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input['LinuxConfigurationArgs'] 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 pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]] secrets: Specifies set of certificates that should be installed onto the virtual machines in the scale set.
          :param pulumi.Input['WindowsConfigurationArgs'] 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[pulumi.Input[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")
  
      @admin_password.setter
      def admin_password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "admin_password", value)
  
      @property
      @pulumi.getter(name="adminUsername")
      def admin_username(self) -> Optional[pulumi.Input[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")
  
      @admin_username.setter
      def admin_username(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "admin_username", value)
  
      @property
      @pulumi.getter(name="computerNamePrefix")
      def computer_name_prefix(self) -> Optional[pulumi.Input[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")
  
      @computer_name_prefix.setter
      def computer_name_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "computer_name_prefix", value)
  
      @property
      @pulumi.getter(name="customData")
      def custom_data(self) -> Optional[pulumi.Input[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")
  
      @custom_data.setter
      def custom_data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "custom_data", value)
  
      @property
      @pulumi.getter(name="linuxConfiguration")
      def linux_configuration(self) -> Optional[pulumi.Input['LinuxConfigurationArgs']]:
          """
          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")
  
      @linux_configuration.setter
      def linux_configuration(self, value: Optional[pulumi.Input['LinuxConfigurationArgs']]):
          pulumi.set(self, "linux_configuration", value)
  
      @property
      @pulumi.getter
      def secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]:
          """
          Specifies set of certificates that should be installed onto the virtual machines in the scale set.
          """
          return pulumi.get(self, "secrets")
  
      @secrets.setter
      def secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VaultSecretGroupArgs']]]]):
          pulumi.set(self, "secrets", value)
  
      @property
      @pulumi.getter(name="windowsConfiguration")
      def windows_configuration(self) -> Optional[pulumi.Input['WindowsConfigurationArgs']]:
          """
          Specifies Windows operating system settings on the virtual machine.
          """
          return pulumi.get(self, "windows_configuration")
  
      @windows_configuration.setter
      def windows_configuration(self, value: Optional[pulumi.Input['WindowsConfigurationArgs']]):
          pulumi.set(self, "windows_configuration", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetPublicIPAddressConfigurationArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   dns_settings: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   ip_tags: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]] = None,
                   public_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
                   public_ip_prefix: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration
          :param pulumi.Input[str] name: The publicIP address configuration name.
          :param pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs'] dns_settings: The dns settings to be applied on the publicIP addresses .
          :param pulumi.Input[int] idle_timeout_in_minutes: The idle timeout of the public IP address.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]] ip_tags: The list of IP tags associated with the public IP address.
          :param pulumi.Input[Union[str, 'IPVersion']] 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 pulumi.Input['SubResourceArgs'] 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) -> pulumi.Input[str]:
          """
          The publicIP address configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="dnsSettings")
      def dns_settings(self) -> Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']]:
          """
          The dns settings to be applied on the publicIP addresses .
          """
          return pulumi.get(self, "dns_settings")
  
      @dns_settings.setter
      def dns_settings(self, value: Optional[pulumi.Input['VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs']]):
          pulumi.set(self, "dns_settings", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The idle timeout of the public IP address.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter(name="ipTags")
      def ip_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]]:
          """
          The list of IP tags associated with the public IP address.
          """
          return pulumi.get(self, "ip_tags")
  
      @ip_tags.setter
      def ip_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetIpTagArgs']]]]):
          pulumi.set(self, "ip_tags", value)
  
      @property
      @pulumi.getter(name="publicIPAddressVersion")
      def public_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
          """
          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")
  
      @public_ip_address_version.setter
      def public_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
          pulumi.set(self, "public_ip_address_version", value)
  
      @property
      @pulumi.getter(name="publicIPPrefix")
      def public_ip_prefix(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The PublicIPPrefix from which to allocate publicIP addresses.
          """
          return pulumi.get(self, "public_ip_prefix")
  
      @public_ip_prefix.setter
      def public_ip_prefix(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_prefix", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettingsArgs:
      def __init__(__self__, *,
                   domain_name_label: pulumi.Input[str]):
          """
          Describes a virtual machines scale sets network configuration's DNS settings.
          :param pulumi.Input[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) -> pulumi.Input[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")
  
      @domain_name_label.setter
      def domain_name_label(self, value: pulumi.Input[str]):
          pulumi.set(self, "domain_name_label", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetStorageProfileArgs:
      def __init__(__self__, *,
                   data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]] = None,
                   image_reference: Optional[pulumi.Input['ImageReferenceArgs']] = None,
                   os_disk: Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']] = None):
          """
          Describes a virtual machine scale set storage profile.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]] 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 pulumi.Input['ImageReferenceArgs'] 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 pulumi.Input['VirtualMachineScaleSetOSDiskArgs'] 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[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]]:
          """
          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")
  
      @data_disks.setter
      def data_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetDataDiskArgs']]]]):
          pulumi.set(self, "data_disks", value)
  
      @property
      @pulumi.getter(name="imageReference")
      def image_reference(self) -> Optional[pulumi.Input['ImageReferenceArgs']]:
          """
          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")
  
      @image_reference.setter
      def image_reference(self, value: Optional[pulumi.Input['ImageReferenceArgs']]):
          pulumi.set(self, "image_reference", value)
  
      @property
      @pulumi.getter(name="osDisk")
      def os_disk(self) -> Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']]:
          """
          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")
  
      @os_disk.setter
      def os_disk(self, value: Optional[pulumi.Input['VirtualMachineScaleSetOSDiskArgs']]):
          pulumi.set(self, "os_disk", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetVMNetworkProfileConfigurationArgs:
      def __init__(__self__, *,
                   network_interface_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]] = None):
          """
          Describes a virtual machine scale set VM network profile.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]] 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[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]:
          """
          The list of network configurations.
          """
          return pulumi.get(self, "network_interface_configurations")
  
      @network_interface_configurations.setter
      def network_interface_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineScaleSetNetworkConfigurationArgs']]]]):
          pulumi.set(self, "network_interface_configurations", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetVMProfileArgs:
      def __init__(__self__, *,
                   billing_profile: Optional[pulumi.Input['BillingProfileArgs']] = None,
                   diagnostics_profile: Optional[pulumi.Input['DiagnosticsProfileArgs']] = None,
                   eviction_policy: Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]] = None,
                   extension_profile: Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']] = None,
                   license_type: Optional[pulumi.Input[str]] = None,
                   network_profile: Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']] = None,
                   os_profile: Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']] = None,
                   priority: Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]] = None,
                   scheduled_events_profile: Optional[pulumi.Input['ScheduledEventsProfileArgs']] = None,
                   storage_profile: Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']] = None):
          """
          Describes a virtual machine scale set virtual machine profile.
          :param pulumi.Input['BillingProfileArgs'] billing_profile: Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
          :param pulumi.Input['DiagnosticsProfileArgs'] diagnostics_profile: Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          :param pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']] eviction_policy: Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, the only supported value is 'Deallocate' 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 pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs'] extension_profile: Specifies a collection of settings for extensions installed on virtual machines in the scale set.
          :param pulumi.Input[str] license_type: Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system. <br><br> Possible values are: <br><br> Windows_Client <br><br> Windows_Server <br><br> If this element is included in a request for an update, the value must match the initial value. This value cannot be updated. <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> Minimum api-version: 2015-06-15
          :param pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs'] network_profile: Specifies properties of the network interfaces of the virtual machines in the scale set.
          :param pulumi.Input['VirtualMachineScaleSetOSProfileArgs'] os_profile: Specifies the operating system settings for the virtual machines in the scale set.
          :param pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']] priority: Specifies the priority for the virtual machines in the scale set. <br><br>Minimum api-version: 2017-10-30-preview
          :param pulumi.Input['ScheduledEventsProfileArgs'] scheduled_events_profile: Specifies Scheduled Event related configurations.
          :param pulumi.Input['VirtualMachineScaleSetStorageProfileArgs'] 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 storage_profile is not None:
              pulumi.set(__self__, "storage_profile", storage_profile)
  
      @property
      @pulumi.getter(name="billingProfile")
      def billing_profile(self) -> Optional[pulumi.Input['BillingProfileArgs']]:
          """
          Specifies the billing related details of a Azure Spot VMSS. <br><br>Minimum api-version: 2019-03-01.
          """
          return pulumi.get(self, "billing_profile")
  
      @billing_profile.setter
      def billing_profile(self, value: Optional[pulumi.Input['BillingProfileArgs']]):
          pulumi.set(self, "billing_profile", value)
  
      @property
      @pulumi.getter(name="diagnosticsProfile")
      def diagnostics_profile(self) -> Optional[pulumi.Input['DiagnosticsProfileArgs']]:
          """
          Specifies the boot diagnostic settings state. <br><br>Minimum api-version: 2015-06-15.
          """
          return pulumi.get(self, "diagnostics_profile")
  
      @diagnostics_profile.setter
      def diagnostics_profile(self, value: Optional[pulumi.Input['DiagnosticsProfileArgs']]):
          pulumi.set(self, "diagnostics_profile", value)
  
      @property
      @pulumi.getter(name="evictionPolicy")
      def eviction_policy(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]]:
          """
          Specifies the eviction policy for the Azure Spot virtual machine and Azure Spot scale set. <br><br>For Azure Spot virtual machines, the only supported value is 'Deallocate' 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")
  
      @eviction_policy.setter
      def eviction_policy(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachineEvictionPolicyTypes']]]):
          pulumi.set(self, "eviction_policy", value)
  
      @property
      @pulumi.getter(name="extensionProfile")
      def extension_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']]:
          """
          Specifies a collection of settings for extensions installed on virtual machines in the scale set.
          """
          return pulumi.get(self, "extension_profile")
  
      @extension_profile.setter
      def extension_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetExtensionProfileArgs']]):
          pulumi.set(self, "extension_profile", value)
  
      @property
      @pulumi.getter(name="licenseType")
      def license_type(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system. <br><br> Possible values are: <br><br> Windows_Client <br><br> Windows_Server <br><br> If this element is included in a request for an update, the value must match the initial value. This value cannot be updated. <br><br> For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json) <br><br> Minimum api-version: 2015-06-15
          """
          return pulumi.get(self, "license_type")
  
      @license_type.setter
      def license_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "license_type", value)
  
      @property
      @pulumi.getter(name="networkProfile")
      def network_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']]:
          """
          Specifies properties of the network interfaces of the virtual machines in the scale set.
          """
          return pulumi.get(self, "network_profile")
  
      @network_profile.setter
      def network_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetNetworkProfileArgs']]):
          pulumi.set(self, "network_profile", value)
  
      @property
      @pulumi.getter(name="osProfile")
      def os_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']]:
          """
          Specifies the operating system settings for the virtual machines in the scale set.
          """
          return pulumi.get(self, "os_profile")
  
      @os_profile.setter
      def os_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetOSProfileArgs']]):
          pulumi.set(self, "os_profile", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]]:
          """
          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")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[Union[str, 'VirtualMachinePriorityTypes']]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter(name="scheduledEventsProfile")
      def scheduled_events_profile(self) -> Optional[pulumi.Input['ScheduledEventsProfileArgs']]:
          """
          Specifies Scheduled Event related configurations.
          """
          return pulumi.get(self, "scheduled_events_profile")
  
      @scheduled_events_profile.setter
      def scheduled_events_profile(self, value: Optional[pulumi.Input['ScheduledEventsProfileArgs']]):
          pulumi.set(self, "scheduled_events_profile", value)
  
      @property
      @pulumi.getter(name="storageProfile")
      def storage_profile(self) -> Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']]:
          """
          Specifies the storage settings for the virtual machine disks.
          """
          return pulumi.get(self, "storage_profile")
  
      @storage_profile.setter
      def storage_profile(self, value: Optional[pulumi.Input['VirtualMachineScaleSetStorageProfileArgs']]):
          pulumi.set(self, "storage_profile", value)
  
  
  @pulumi.input_type
  class VirtualMachineScaleSetVMProtectionPolicyArgs:
      def __init__(__self__, *,
                   protect_from_scale_in: Optional[pulumi.Input[bool]] = None,
                   protect_from_scale_set_actions: Optional[pulumi.Input[bool]] = None):
          """
          The protection policy of a virtual machine scale set VM.
          :param pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")
  
      @protect_from_scale_in.setter
      def protect_from_scale_in(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "protect_from_scale_in", value)
  
      @property
      @pulumi.getter(name="protectFromScaleSetActions")
      def protect_from_scale_set_actions(self) -> Optional[pulumi.Input[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")
  
      @protect_from_scale_set_actions.setter
      def protect_from_scale_set_actions(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "protect_from_scale_set_actions", value)
  
  
  @pulumi.input_type
  class WinRMConfigurationArgs:
      def __init__(__self__, *,
                   listeners: Optional[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]] = None):
          """
          Describes Windows Remote Management configuration of the VM
          :param pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]] 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[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]]:
          """
          The list of Windows Remote Management listeners
          """
          return pulumi.get(self, "listeners")
  
      @listeners.setter
      def listeners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WinRMListenerArgs']]]]):
          pulumi.set(self, "listeners", value)
  
  
  @pulumi.input_type
  class WinRMListenerArgs:
      def __init__(__self__, *,
                   certificate_url: Optional[pulumi.Input[str]] = None,
                   protocol: Optional[pulumi.Input['ProtocolTypes']] = None):
          """
          Describes Protocol and thumbprint of Windows Remote Management listener
          :param pulumi.Input[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 pulumi.Input['ProtocolTypes'] 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[pulumi.Input[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")
  
      @certificate_url.setter
      def certificate_url(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "certificate_url", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input['ProtocolTypes']]:
          """
          Specifies the protocol of WinRM listener. <br><br> Possible values are: <br>**http** <br><br> **https**
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input['ProtocolTypes']]):
          pulumi.set(self, "protocol", value)
  
  
  @pulumi.input_type
  class WindowsConfigurationArgs:
      def __init__(__self__, *,
                   additional_unattend_content: Optional[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]] = None,
                   enable_automatic_updates: Optional[pulumi.Input[bool]] = None,
                   provision_vm_agent: Optional[pulumi.Input[bool]] = None,
                   time_zone: Optional[pulumi.Input[str]] = None,
                   win_rm: Optional[pulumi.Input['WinRMConfigurationArgs']] = None):
          """
          Specifies Windows operating system settings on the virtual machine.
          :param pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]] 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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input['WinRMConfigurationArgs'] 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 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[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]]:
          """
          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")
  
      @additional_unattend_content.setter
      def additional_unattend_content(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AdditionalUnattendContentArgs']]]]):
          pulumi.set(self, "additional_unattend_content", value)
  
      @property
      @pulumi.getter(name="enableAutomaticUpdates")
      def enable_automatic_updates(self) -> Optional[pulumi.Input[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")
  
      @enable_automatic_updates.setter
      def enable_automatic_updates(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_automatic_updates", value)
  
      @property
      @pulumi.getter(name="provisionVMAgent")
      def provision_vm_agent(self) -> Optional[pulumi.Input[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")
  
      @provision_vm_agent.setter
      def provision_vm_agent(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "provision_vm_agent", value)
  
      @property
      @pulumi.getter(name="timeZone")
      def time_zone(self) -> Optional[pulumi.Input[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")
  
      @time_zone.setter
      def time_zone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "time_zone", value)
  
      @property
      @pulumi.getter(name="winRM")
      def win_rm(self) -> Optional[pulumi.Input['WinRMConfigurationArgs']]:
          """
          Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
          """
          return pulumi.get(self, "win_rm")
  
      @win_rm.setter
      def win_rm(self, value: Optional[pulumi.Input['WinRMConfigurationArgs']]):
          pulumi.set(self, "win_rm", value)
  
  
  