zz_generated_enums.go

// +build go1.13

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package armcompute

type AccessLevel string

const (
	AccessLevelNone  AccessLevel = "None"
	AccessLevelRead  AccessLevel = "Read"
	AccessLevelWrite AccessLevel = "Write"
)

func PossibleAccessLevelValues() []AccessLevel {
	return []AccessLevel{
		AccessLevelNone,
		AccessLevelRead,
		AccessLevelWrite,
	}
}

func (c AccessLevel) ToPtr() *AccessLevel {
	return &c
}

// AggregatedReplicationState - This is the aggregated replication status based on all the regional replication status flags.
type AggregatedReplicationState string

const (
	AggregatedReplicationStateCompleted  AggregatedReplicationState = "Completed"
	AggregatedReplicationStateFailed     AggregatedReplicationState = "Failed"
	AggregatedReplicationStateInProgress AggregatedReplicationState = "InProgress"
	AggregatedReplicationStateUnknown    AggregatedReplicationState = "Unknown"
)

func PossibleAggregatedReplicationStateValues() []AggregatedReplicationState {
	return []AggregatedReplicationState{
		AggregatedReplicationStateCompleted,
		AggregatedReplicationStateFailed,
		AggregatedReplicationStateInProgress,
		AggregatedReplicationStateUnknown,
	}
}

func (c AggregatedReplicationState) ToPtr() *AggregatedReplicationState {
	return &c
}

// AvailabilitySetSKUTypes - Specifies the sku of an Availability Set. Use 'Aligned' for virtual machines with managed disks and 'Classic' for virtual machines
// with unmanaged disks. Default value is 'Classic'.
type AvailabilitySetSKUTypes string

const (
	AvailabilitySetSKUTypesAligned AvailabilitySetSKUTypes = "Aligned"
	AvailabilitySetSKUTypesClassic AvailabilitySetSKUTypes = "Classic"
)

func PossibleAvailabilitySetSKUTypesValues() []AvailabilitySetSKUTypes {
	return []AvailabilitySetSKUTypes{
		AvailabilitySetSKUTypesAligned,
		AvailabilitySetSKUTypesClassic,
	}
}

func (c AvailabilitySetSKUTypes) ToPtr() *AvailabilitySetSKUTypes {
	return &c
}

// CachingTypes - Specifies the caching requirements.
// Possible values are:
// None
// ReadOnly
// ReadWrite
// Default: None for Standard storage. ReadOnly for Premium storage
type CachingTypes string

const (
	CachingTypesNone      CachingTypes = "None"
	CachingTypesReadOnly  CachingTypes = "ReadOnly"
	CachingTypesReadWrite CachingTypes = "ReadWrite"
)

func PossibleCachingTypesValues() []CachingTypes {
	return []CachingTypes{
		CachingTypesNone,
		CachingTypesReadOnly,
		CachingTypesReadWrite,
	}
}

func (c CachingTypes) ToPtr() *CachingTypes {
	return &c
}

// ContainerServiceOrchestratorTypes - The orchestrator to use to manage container service cluster resources. Valid values are Swarm, DCOS, and Custom.
type ContainerServiceOrchestratorTypes string

const (
	ContainerServiceOrchestratorTypesSwarm      ContainerServiceOrchestratorTypes = "Swarm"
	ContainerServiceOrchestratorTypesDcos       ContainerServiceOrchestratorTypes = "DCOS"
	ContainerServiceOrchestratorTypesCustom     ContainerServiceOrchestratorTypes = "Custom"
	ContainerServiceOrchestratorTypesKubernetes ContainerServiceOrchestratorTypes = "Kubernetes"
)

func PossibleContainerServiceOrchestratorTypesValues() []ContainerServiceOrchestratorTypes {
	return []ContainerServiceOrchestratorTypes{
		ContainerServiceOrchestratorTypesSwarm,
		ContainerServiceOrchestratorTypesDcos,
		ContainerServiceOrchestratorTypesCustom,
		ContainerServiceOrchestratorTypesKubernetes,
	}
}

func (c ContainerServiceOrchestratorTypes) ToPtr() *ContainerServiceOrchestratorTypes {
	return &c
}

// ContainerServiceVMSizeTypes - Size of agent VMs.
type ContainerServiceVMSizeTypes string

const (
	ContainerServiceVMSizeTypesStandardA0    ContainerServiceVMSizeTypes = "Standard_A0"
	ContainerServiceVMSizeTypesStandardA1    ContainerServiceVMSizeTypes = "Standard_A1"
	ContainerServiceVMSizeTypesStandardA10   ContainerServiceVMSizeTypes = "Standard_A10"
	ContainerServiceVMSizeTypesStandardA11   ContainerServiceVMSizeTypes = "Standard_A11"
	ContainerServiceVMSizeTypesStandardA2    ContainerServiceVMSizeTypes = "Standard_A2"
	ContainerServiceVMSizeTypesStandardA3    ContainerServiceVMSizeTypes = "Standard_A3"
	ContainerServiceVMSizeTypesStandardA4    ContainerServiceVMSizeTypes = "Standard_A4"
	ContainerServiceVMSizeTypesStandardA5    ContainerServiceVMSizeTypes = "Standard_A5"
	ContainerServiceVMSizeTypesStandardA6    ContainerServiceVMSizeTypes = "Standard_A6"
	ContainerServiceVMSizeTypesStandardA7    ContainerServiceVMSizeTypes = "Standard_A7"
	ContainerServiceVMSizeTypesStandardA8    ContainerServiceVMSizeTypes = "Standard_A8"
	ContainerServiceVMSizeTypesStandardA9    ContainerServiceVMSizeTypes = "Standard_A9"
	ContainerServiceVMSizeTypesStandardD1    ContainerServiceVMSizeTypes = "Standard_D1"
	ContainerServiceVMSizeTypesStandardD11   ContainerServiceVMSizeTypes = "Standard_D11"
	ContainerServiceVMSizeTypesStandardD11V2 ContainerServiceVMSizeTypes = "Standard_D11_v2"
	ContainerServiceVMSizeTypesStandardD12   ContainerServiceVMSizeTypes = "Standard_D12"
	ContainerServiceVMSizeTypesStandardD12V2 ContainerServiceVMSizeTypes = "Standard_D12_v2"
	ContainerServiceVMSizeTypesStandardD13   ContainerServiceVMSizeTypes = "Standard_D13"
	ContainerServiceVMSizeTypesStandardD13V2 ContainerServiceVMSizeTypes = "Standard_D13_v2"
	ContainerServiceVMSizeTypesStandardD14   ContainerServiceVMSizeTypes = "Standard_D14"
	ContainerServiceVMSizeTypesStandardD14V2 ContainerServiceVMSizeTypes = "Standard_D14_v2"
	ContainerServiceVMSizeTypesStandardD1V2  ContainerServiceVMSizeTypes = "Standard_D1_v2"
	ContainerServiceVMSizeTypesStandardD2    ContainerServiceVMSizeTypes = "Standard_D2"
	ContainerServiceVMSizeTypesStandardD2V2  ContainerServiceVMSizeTypes = "Standard_D2_v2"
	ContainerServiceVMSizeTypesStandardD3    ContainerServiceVMSizeTypes = "Standard_D3"
	ContainerServiceVMSizeTypesStandardD3V2  ContainerServiceVMSizeTypes = "Standard_D3_v2"
	ContainerServiceVMSizeTypesStandardD4    ContainerServiceVMSizeTypes = "Standard_D4"
	ContainerServiceVMSizeTypesStandardD4V2  ContainerServiceVMSizeTypes = "Standard_D4_v2"
	ContainerServiceVMSizeTypesStandardD5V2  ContainerServiceVMSizeTypes = "Standard_D5_v2"
	ContainerServiceVMSizeTypesStandardDs1   ContainerServiceVMSizeTypes = "Standard_DS1"
	ContainerServiceVMSizeTypesStandardDs11  ContainerServiceVMSizeTypes = "Standard_DS11"
	ContainerServiceVMSizeTypesStandardDs12  ContainerServiceVMSizeTypes = "Standard_DS12"
	ContainerServiceVMSizeTypesStandardDs13  ContainerServiceVMSizeTypes = "Standard_DS13"
	ContainerServiceVMSizeTypesStandardDs14  ContainerServiceVMSizeTypes = "Standard_DS14"
	ContainerServiceVMSizeTypesStandardDs2   ContainerServiceVMSizeTypes = "Standard_DS2"
	ContainerServiceVMSizeTypesStandardDs3   ContainerServiceVMSizeTypes = "Standard_DS3"
	ContainerServiceVMSizeTypesStandardDs4   ContainerServiceVMSizeTypes = "Standard_DS4"
	ContainerServiceVMSizeTypesStandardG1    ContainerServiceVMSizeTypes = "Standard_G1"
	ContainerServiceVMSizeTypesStandardG2    ContainerServiceVMSizeTypes = "Standard_G2"
	ContainerServiceVMSizeTypesStandardG3    ContainerServiceVMSizeTypes = "Standard_G3"
	ContainerServiceVMSizeTypesStandardG4    ContainerServiceVMSizeTypes = "Standard_G4"
	ContainerServiceVMSizeTypesStandardG5    ContainerServiceVMSizeTypes = "Standard_G5"
	ContainerServiceVMSizeTypesStandardGs1   ContainerServiceVMSizeTypes = "Standard_GS1"
	ContainerServiceVMSizeTypesStandardGs2   ContainerServiceVMSizeTypes = "Standard_GS2"
	ContainerServiceVMSizeTypesStandardGs3   ContainerServiceVMSizeTypes = "Standard_GS3"
	ContainerServiceVMSizeTypesStandardGs4   ContainerServiceVMSizeTypes = "Standard_GS4"
	ContainerServiceVMSizeTypesStandardGs5   ContainerServiceVMSizeTypes = "Standard_GS5"
)

func PossibleContainerServiceVMSizeTypesValues() []ContainerServiceVMSizeTypes {
	return []ContainerServiceVMSizeTypes{
		ContainerServiceVMSizeTypesStandardA0,
		ContainerServiceVMSizeTypesStandardA1,
		ContainerServiceVMSizeTypesStandardA10,
		ContainerServiceVMSizeTypesStandardA11,
		ContainerServiceVMSizeTypesStandardA2,
		ContainerServiceVMSizeTypesStandardA3,
		ContainerServiceVMSizeTypesStandardA4,
		ContainerServiceVMSizeTypesStandardA5,
		ContainerServiceVMSizeTypesStandardA6,
		ContainerServiceVMSizeTypesStandardA7,
		ContainerServiceVMSizeTypesStandardA8,
		ContainerServiceVMSizeTypesStandardA9,
		ContainerServiceVMSizeTypesStandardD1,
		ContainerServiceVMSizeTypesStandardD11,
		ContainerServiceVMSizeTypesStandardD11V2,
		ContainerServiceVMSizeTypesStandardD12,
		ContainerServiceVMSizeTypesStandardD12V2,
		ContainerServiceVMSizeTypesStandardD13,
		ContainerServiceVMSizeTypesStandardD13V2,
		ContainerServiceVMSizeTypesStandardD14,
		ContainerServiceVMSizeTypesStandardD14V2,
		ContainerServiceVMSizeTypesStandardD1V2,
		ContainerServiceVMSizeTypesStandardD2,
		ContainerServiceVMSizeTypesStandardD2V2,
		ContainerServiceVMSizeTypesStandardD3,
		ContainerServiceVMSizeTypesStandardD3V2,
		ContainerServiceVMSizeTypesStandardD4,
		ContainerServiceVMSizeTypesStandardD4V2,
		ContainerServiceVMSizeTypesStandardD5V2,
		ContainerServiceVMSizeTypesStandardDs1,
		ContainerServiceVMSizeTypesStandardDs11,
		ContainerServiceVMSizeTypesStandardDs12,
		ContainerServiceVMSizeTypesStandardDs13,
		ContainerServiceVMSizeTypesStandardDs14,
		ContainerServiceVMSizeTypesStandardDs2,
		ContainerServiceVMSizeTypesStandardDs3,
		ContainerServiceVMSizeTypesStandardDs4,
		ContainerServiceVMSizeTypesStandardG1,
		ContainerServiceVMSizeTypesStandardG2,
		ContainerServiceVMSizeTypesStandardG3,
		ContainerServiceVMSizeTypesStandardG4,
		ContainerServiceVMSizeTypesStandardG5,
		ContainerServiceVMSizeTypesStandardGs1,
		ContainerServiceVMSizeTypesStandardGs2,
		ContainerServiceVMSizeTypesStandardGs3,
		ContainerServiceVMSizeTypesStandardGs4,
		ContainerServiceVMSizeTypesStandardGs5,
	}
}

func (c ContainerServiceVMSizeTypes) ToPtr() *ContainerServiceVMSizeTypes {
	return &c
}

// DedicatedHostLicenseTypes - Specifies the software license type that will be applied to the VMs deployed on the dedicated host.
// Possible values are:
// None
// WindowsServerHybrid
// WindowsServerPerpetual
// Default: None
type DedicatedHostLicenseTypes string

const (
	DedicatedHostLicenseTypesNone                   DedicatedHostLicenseTypes = "None"
	DedicatedHostLicenseTypesWindowsServerHybrid    DedicatedHostLicenseTypes = "Windows_Server_Hybrid"
	DedicatedHostLicenseTypesWindowsServerPerpetual DedicatedHostLicenseTypes = "Windows_Server_Perpetual"
)

func PossibleDedicatedHostLicenseTypesValues() []DedicatedHostLicenseTypes {
	return []DedicatedHostLicenseTypes{
		DedicatedHostLicenseTypesNone,
		DedicatedHostLicenseTypesWindowsServerHybrid,
		DedicatedHostLicenseTypesWindowsServerPerpetual,
	}
}

func (c DedicatedHostLicenseTypes) ToPtr() *DedicatedHostLicenseTypes {
	return &c
}

// DiffDiskOptions - Specifies the ephemeral disk option for operating system disk.
type DiffDiskOptions string

const (
	DiffDiskOptionsLocal DiffDiskOptions = "Local"
)

func PossibleDiffDiskOptionsValues() []DiffDiskOptions {
	return []DiffDiskOptions{
		DiffDiskOptionsLocal,
	}
}

func (c DiffDiskOptions) ToPtr() *DiffDiskOptions {
	return &c
}

// DiffDiskPlacement - Specifies the ephemeral disk placement for operating system disk. This property can be used by user in the request to choose the
// location i.e, cache disk or resource disk space for Ephemeral OS disk
// provisioning. For more information on Ephemeral OS disk size requirements, please refer Ephemeral OS disk size requirements for Windows VM at
// https://docs.microsoft.com/en-us/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements and Linux VM at
// https://docs.microsoft.com/en-us/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements
type DiffDiskPlacement string

const (
	DiffDiskPlacementCacheDisk    DiffDiskPlacement = "CacheDisk"
	DiffDiskPlacementResourceDisk DiffDiskPlacement = "ResourceDisk"
)

func PossibleDiffDiskPlacementValues() []DiffDiskPlacement {
	return []DiffDiskPlacement{
		DiffDiskPlacementCacheDisk,
		DiffDiskPlacementResourceDisk,
	}
}

func (c DiffDiskPlacement) ToPtr() *DiffDiskPlacement {
	return &c
}

// DiskCreateOption - This enumerates the possible sources of a disk's creation.
type DiskCreateOption string

const (
	// DiskCreateOptionAttach - Disk will be attached to a VM.
	DiskCreateOptionAttach DiskCreateOption = "Attach"
	// DiskCreateOptionCopy - Create a new disk or snapshot by copying from a disk or snapshot specified by the given sourceResourceId.
	DiskCreateOptionCopy DiskCreateOption = "Copy"
	// DiskCreateOptionEmpty - Create an empty data disk of a size given by diskSizeGB.
	DiskCreateOptionEmpty DiskCreateOption = "Empty"
	// DiskCreateOptionFromImage - Create a new disk from a platform image specified by the given imageReference or galleryImageReference.
	DiskCreateOptionFromImage DiskCreateOption = "FromImage"
	// DiskCreateOptionImport - Create a disk by importing from a blob specified by a sourceUri in a storage account specified by storageAccountId.
	DiskCreateOptionImport DiskCreateOption = "Import"
	// DiskCreateOptionRestore - Create a new disk by copying from a backup recovery point.
	DiskCreateOptionRestore DiskCreateOption = "Restore"
	// DiskCreateOptionUpload - Create a new disk by obtaining a write token and using it to directly upload the contents of the disk.
	DiskCreateOptionUpload DiskCreateOption = "Upload"
)

func PossibleDiskCreateOptionValues() []DiskCreateOption {
	return []DiskCreateOption{
		DiskCreateOptionAttach,
		DiskCreateOptionCopy,
		DiskCreateOptionEmpty,
		DiskCreateOptionFromImage,
		DiskCreateOptionImport,
		DiskCreateOptionRestore,
		DiskCreateOptionUpload,
	}
}

func (c DiskCreateOption) ToPtr() *DiskCreateOption {
	return &c
}

// DiskCreateOptionTypes - Specifies how the virtual machine should be created.
// Possible values are:
// Attach \u2013 This value is used when you are using a specialized disk to create the virtual machine.
// 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.
type DiskCreateOptionTypes string

const (
	DiskCreateOptionTypesAttach    DiskCreateOptionTypes = "Attach"
	DiskCreateOptionTypesEmpty     DiskCreateOptionTypes = "Empty"
	DiskCreateOptionTypesFromImage DiskCreateOptionTypes = "FromImage"
)

func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes {
	return []DiskCreateOptionTypes{
		DiskCreateOptionTypesAttach,
		DiskCreateOptionTypesEmpty,
		DiskCreateOptionTypesFromImage,
	}
}

func (c DiskCreateOptionTypes) ToPtr() *DiskCreateOptionTypes {
	return &c
}

// DiskEncryptionSetIDentityType - The type of Managed Identity used by the DiskEncryptionSet. Only SystemAssigned is supported.
type DiskEncryptionSetIDentityType string

const (
	DiskEncryptionSetIDentityTypeSystemAssigned DiskEncryptionSetIDentityType = "SystemAssigned"
)

func PossibleDiskEncryptionSetIDentityTypeValues() []DiskEncryptionSetIDentityType {
	return []DiskEncryptionSetIDentityType{
		DiskEncryptionSetIDentityTypeSystemAssigned,
	}
}

func (c DiskEncryptionSetIDentityType) ToPtr() *DiskEncryptionSetIDentityType {
	return &c
}

// DiskEncryptionSetType - The type of key used to encrypt the data of the disk.
type DiskEncryptionSetType string

const (
	// DiskEncryptionSetTypeEncryptionAtRestWithCustomerKey - Resource using diskEncryptionSet would be encrypted at rest with Customer managed key that can
	// be changed and revoked by a customer.
	DiskEncryptionSetTypeEncryptionAtRestWithCustomerKey DiskEncryptionSetType = "EncryptionAtRestWithCustomerKey"
	// DiskEncryptionSetTypeEncryptionAtRestWithPlatformAndCustomerKeys - Resource using diskEncryptionSet would be encrypted at rest with two layers of encryption.
	// One of the keys is Customer managed and the other key is Platform managed.
	DiskEncryptionSetTypeEncryptionAtRestWithPlatformAndCustomerKeys DiskEncryptionSetType = "EncryptionAtRestWithPlatformAndCustomerKeys"
)

func PossibleDiskEncryptionSetTypeValues() []DiskEncryptionSetType {
	return []DiskEncryptionSetType{
		DiskEncryptionSetTypeEncryptionAtRestWithCustomerKey,
		DiskEncryptionSetTypeEncryptionAtRestWithPlatformAndCustomerKeys,
	}
}

func (c DiskEncryptionSetType) ToPtr() *DiskEncryptionSetType {
	return &c
}

// DiskState - This enumerates the possible state of the disk.
type DiskState string

const (
	// DiskStateActiveSas - The disk currently has an Active SAS Uri associated with it.
	DiskStateActiveSas DiskState = "ActiveSAS"
	// DiskStateActiveUpload - A disk is created for upload and a write token has been issued for uploading to it.
	DiskStateActiveUpload DiskState = "ActiveUpload"
	// DiskStateAttached - The disk is currently mounted to a running VM.
	DiskStateAttached DiskState = "Attached"
	// DiskStateReadyToUpload - A disk is ready to be created by upload by requesting a write token.
	DiskStateReadyToUpload DiskState = "ReadyToUpload"
	// DiskStateReserved - The disk is mounted to a stopped-deallocated VM
	DiskStateReserved DiskState = "Reserved"
	// DiskStateUnattached - The disk is not being used and can be attached to a VM.
	DiskStateUnattached DiskState = "Unattached"
)

func PossibleDiskStateValues() []DiskState {
	return []DiskState{
		DiskStateActiveSas,
		DiskStateActiveUpload,
		DiskStateAttached,
		DiskStateReadyToUpload,
		DiskStateReserved,
		DiskStateUnattached,
	}
}

func (c DiskState) ToPtr() *DiskState {
	return &c
}

// DiskStorageAccountTypes - The sku name.
type DiskStorageAccountTypes string

const (
	// DiskStorageAccountTypesPremiumLrs - Premium SSD locally redundant storage. Best for production and performance sensitive workloads.
	DiskStorageAccountTypesPremiumLrs DiskStorageAccountTypes = "Premium_LRS"
	// DiskStorageAccountTypesStandardLrs - Standard HDD locally redundant storage. Best for backup, non-critical, and infrequent access.
	DiskStorageAccountTypesStandardLrs DiskStorageAccountTypes = "Standard_LRS"
	// DiskStorageAccountTypesStandardSsdlrs - Standard SSD locally redundant storage. Best for web servers, lightly used enterprise applications and dev/test.
	DiskStorageAccountTypesStandardSsdlrs DiskStorageAccountTypes = "StandardSSD_LRS"
	// DiskStorageAccountTypesUltraSsdlrs - Ultra SSD locally redundant storage. Best for IO-intensive workloads such as SAP HANA, top tier databases (for example,
	// SQL, Oracle), and other transaction-heavy workloads.
	DiskStorageAccountTypesUltraSsdlrs DiskStorageAccountTypes = "UltraSSD_LRS"
)

func PossibleDiskStorageAccountTypesValues() []DiskStorageAccountTypes {
	return []DiskStorageAccountTypes{
		DiskStorageAccountTypesPremiumLrs,
		DiskStorageAccountTypesStandardLrs,
		DiskStorageAccountTypesStandardSsdlrs,
		DiskStorageAccountTypesUltraSsdlrs,
	}
}

func (c DiskStorageAccountTypes) ToPtr() *DiskStorageAccountTypes {
	return &c
}

// EncryptionType - The type of key used to encrypt the data of the disk.
type EncryptionType string

const (
	// EncryptionTypeEncryptionAtRestWithCustomerKey - Disk is encrypted at rest with Customer managed key that can be changed and revoked by a customer.
	EncryptionTypeEncryptionAtRestWithCustomerKey EncryptionType = "EncryptionAtRestWithCustomerKey"
	// EncryptionTypeEncryptionAtRestWithPlatformAndCustomerKeys - Disk is encrypted at rest with 2 layers of encryption. One of the keys is Customer managed
	// and the other key is Platform managed.
	EncryptionTypeEncryptionAtRestWithPlatformAndCustomerKeys EncryptionType = "EncryptionAtRestWithPlatformAndCustomerKeys"
	// EncryptionTypeEncryptionAtRestWithPlatformKey - Disk is encrypted at rest with Platform managed key. It is the default encryption type. This is not a
	// valid encryption type for disk encryption sets.
	EncryptionTypeEncryptionAtRestWithPlatformKey EncryptionType = "EncryptionAtRestWithPlatformKey"
)

func PossibleEncryptionTypeValues() []EncryptionType {
	return []EncryptionType{
		EncryptionTypeEncryptionAtRestWithCustomerKey,
		EncryptionTypeEncryptionAtRestWithPlatformAndCustomerKeys,
		EncryptionTypeEncryptionAtRestWithPlatformKey,
	}
}

func (c EncryptionType) ToPtr() *EncryptionType {
	return &c
}

// Enum47 - Number of masters (VMs) in the container service cluster. Allowed values are 1, 3, and 5. The default value is 1.
type Enum47 int32

const (
	Enum47Five  Enum47 = 5
	Enum47One   Enum47 = 1
	Enum47Three Enum47 = 3
)

func PossibleEnum47Values() []Enum47 {
	return []Enum47{
		Enum47Five,
		Enum47One,
		Enum47Three,
	}
}

func (c Enum47) ToPtr() *Enum47 {
	return &c
}

// ExecutionState - Script execution status.
type ExecutionState string

const (
	ExecutionStateCanceled  ExecutionState = "Canceled"
	ExecutionStateFailed    ExecutionState = "Failed"
	ExecutionStatePending   ExecutionState = "Pending"
	ExecutionStateRunning   ExecutionState = "Running"
	ExecutionStateSucceeded ExecutionState = "Succeeded"
	ExecutionStateTimedOut  ExecutionState = "TimedOut"
	ExecutionStateUnknown   ExecutionState = "Unknown"
)

func PossibleExecutionStateValues() []ExecutionState {
	return []ExecutionState{
		ExecutionStateCanceled,
		ExecutionStateFailed,
		ExecutionStatePending,
		ExecutionStateRunning,
		ExecutionStateSucceeded,
		ExecutionStateTimedOut,
		ExecutionStateUnknown,
	}
}

func (c ExecutionState) ToPtr() *ExecutionState {
	return &c
}

// GalleryApplicationVersionPropertiesProvisioningState - The provisioning state, which only appears in the response.
type GalleryApplicationVersionPropertiesProvisioningState string

const (
	GalleryApplicationVersionPropertiesProvisioningStateCreating  GalleryApplicationVersionPropertiesProvisioningState = "Creating"
	GalleryApplicationVersionPropertiesProvisioningStateDeleting  GalleryApplicationVersionPropertiesProvisioningState = "Deleting"
	GalleryApplicationVersionPropertiesProvisioningStateFailed    GalleryApplicationVersionPropertiesProvisioningState = "Failed"
	GalleryApplicationVersionPropertiesProvisioningStateMigrating GalleryApplicationVersionPropertiesProvisioningState = "Migrating"
	GalleryApplicationVersionPropertiesProvisioningStateSucceeded GalleryApplicationVersionPropertiesProvisioningState = "Succeeded"
	GalleryApplicationVersionPropertiesProvisioningStateUpdating  GalleryApplicationVersionPropertiesProvisioningState = "Updating"
)

func PossibleGalleryApplicationVersionPropertiesProvisioningStateValues() []GalleryApplicationVersionPropertiesProvisioningState {
	return []GalleryApplicationVersionPropertiesProvisioningState{
		GalleryApplicationVersionPropertiesProvisioningStateCreating,
		GalleryApplicationVersionPropertiesProvisioningStateDeleting,
		GalleryApplicationVersionPropertiesProvisioningStateFailed,
		GalleryApplicationVersionPropertiesProvisioningStateMigrating,
		GalleryApplicationVersionPropertiesProvisioningStateSucceeded,
		GalleryApplicationVersionPropertiesProvisioningStateUpdating,
	}
}

func (c GalleryApplicationVersionPropertiesProvisioningState) ToPtr() *GalleryApplicationVersionPropertiesProvisioningState {
	return &c
}

// GalleryImagePropertiesProvisioningState - The provisioning state, which only appears in the response.
type GalleryImagePropertiesProvisioningState string

const (
	GalleryImagePropertiesProvisioningStateCreating  GalleryImagePropertiesProvisioningState = "Creating"
	GalleryImagePropertiesProvisioningStateDeleting  GalleryImagePropertiesProvisioningState = "Deleting"
	GalleryImagePropertiesProvisioningStateFailed    GalleryImagePropertiesProvisioningState = "Failed"
	GalleryImagePropertiesProvisioningStateMigrating GalleryImagePropertiesProvisioningState = "Migrating"
	GalleryImagePropertiesProvisioningStateSucceeded GalleryImagePropertiesProvisioningState = "Succeeded"
	GalleryImagePropertiesProvisioningStateUpdating  GalleryImagePropertiesProvisioningState = "Updating"
)

func PossibleGalleryImagePropertiesProvisioningStateValues() []GalleryImagePropertiesProvisioningState {
	return []GalleryImagePropertiesProvisioningState{
		GalleryImagePropertiesProvisioningStateCreating,
		GalleryImagePropertiesProvisioningStateDeleting,
		GalleryImagePropertiesProvisioningStateFailed,
		GalleryImagePropertiesProvisioningStateMigrating,
		GalleryImagePropertiesProvisioningStateSucceeded,
		GalleryImagePropertiesProvisioningStateUpdating,
	}
}

func (c GalleryImagePropertiesProvisioningState) ToPtr() *GalleryImagePropertiesProvisioningState {
	return &c
}

// GalleryImageVersionPropertiesProvisioningState - The provisioning state, which only appears in the response.
type GalleryImageVersionPropertiesProvisioningState string

const (
	GalleryImageVersionPropertiesProvisioningStateCreating  GalleryImageVersionPropertiesProvisioningState = "Creating"
	GalleryImageVersionPropertiesProvisioningStateDeleting  GalleryImageVersionPropertiesProvisioningState = "Deleting"
	GalleryImageVersionPropertiesProvisioningStateFailed    GalleryImageVersionPropertiesProvisioningState = "Failed"
	GalleryImageVersionPropertiesProvisioningStateMigrating GalleryImageVersionPropertiesProvisioningState = "Migrating"
	GalleryImageVersionPropertiesProvisioningStateSucceeded GalleryImageVersionPropertiesProvisioningState = "Succeeded"
	GalleryImageVersionPropertiesProvisioningStateUpdating  GalleryImageVersionPropertiesProvisioningState = "Updating"
)

func PossibleGalleryImageVersionPropertiesProvisioningStateValues() []GalleryImageVersionPropertiesProvisioningState {
	return []GalleryImageVersionPropertiesProvisioningState{
		GalleryImageVersionPropertiesProvisioningStateCreating,
		GalleryImageVersionPropertiesProvisioningStateDeleting,
		GalleryImageVersionPropertiesProvisioningStateFailed,
		GalleryImageVersionPropertiesProvisioningStateMigrating,
		GalleryImageVersionPropertiesProvisioningStateSucceeded,
		GalleryImageVersionPropertiesProvisioningStateUpdating,
	}
}

func (c GalleryImageVersionPropertiesProvisioningState) ToPtr() *GalleryImageVersionPropertiesProvisioningState {
	return &c
}

// GalleryPropertiesProvisioningState - The provisioning state, which only appears in the response.
type GalleryPropertiesProvisioningState string

const (
	GalleryPropertiesProvisioningStateCreating  GalleryPropertiesProvisioningState = "Creating"
	GalleryPropertiesProvisioningStateDeleting  GalleryPropertiesProvisioningState = "Deleting"
	GalleryPropertiesProvisioningStateFailed    GalleryPropertiesProvisioningState = "Failed"
	GalleryPropertiesProvisioningStateMigrating GalleryPropertiesProvisioningState = "Migrating"
	GalleryPropertiesProvisioningStateSucceeded GalleryPropertiesProvisioningState = "Succeeded"
	GalleryPropertiesProvisioningStateUpdating  GalleryPropertiesProvisioningState = "Updating"
)

func PossibleGalleryPropertiesProvisioningStateValues() []GalleryPropertiesProvisioningState {
	return []GalleryPropertiesProvisioningState{
		GalleryPropertiesProvisioningStateCreating,
		GalleryPropertiesProvisioningStateDeleting,
		GalleryPropertiesProvisioningStateFailed,
		GalleryPropertiesProvisioningStateMigrating,
		GalleryPropertiesProvisioningStateSucceeded,
		GalleryPropertiesProvisioningStateUpdating,
	}
}

func (c GalleryPropertiesProvisioningState) ToPtr() *GalleryPropertiesProvisioningState {
	return &c
}

// GallerySharingPermissionTypes - This property allows you to specify the permission of sharing gallery.
// Possible values are:
// Private
// Groups
type GallerySharingPermissionTypes string

const (
	GallerySharingPermissionTypesGroups  GallerySharingPermissionTypes = "Groups"
	GallerySharingPermissionTypesPrivate GallerySharingPermissionTypes = "Private"
)

func PossibleGallerySharingPermissionTypesValues() []GallerySharingPermissionTypes {
	return []GallerySharingPermissionTypes{
		GallerySharingPermissionTypesGroups,
		GallerySharingPermissionTypesPrivate,
	}
}

func (c GallerySharingPermissionTypes) ToPtr() *GallerySharingPermissionTypes {
	return &c
}

// HostCaching - The host caching of the disk. Valid values are 'None', 'ReadOnly', and 'ReadWrite'
type HostCaching string

const (
	HostCachingNone      HostCaching = "None"
	HostCachingReadOnly  HostCaching = "ReadOnly"
	HostCachingReadWrite HostCaching = "ReadWrite"
)

func PossibleHostCachingValues() []HostCaching {
	return []HostCaching{
		HostCachingNone,
		HostCachingReadOnly,
		HostCachingReadWrite,
	}
}

func (c HostCaching) ToPtr() *HostCaching {
	return &c
}

// HyperVGeneration - The hypervisor generation of the Virtual Machine. Applicable to OS disks only.
type HyperVGeneration string

const (
	HyperVGenerationV1 HyperVGeneration = "V1"
	HyperVGenerationV2 HyperVGeneration = "V2"
)

func PossibleHyperVGenerationValues() []HyperVGeneration {
	return []HyperVGeneration{
		HyperVGenerationV1,
		HyperVGenerationV2,
	}
}

func (c HyperVGeneration) ToPtr() *HyperVGeneration {
	return &c
}

// HyperVGenerationType - Specifies the HyperVGeneration Type associated with a resource
type HyperVGenerationType string

const (
	HyperVGenerationTypeV1 HyperVGenerationType = "V1"
	HyperVGenerationTypeV2 HyperVGenerationType = "V2"
)

func PossibleHyperVGenerationTypeValues() []HyperVGenerationType {
	return []HyperVGenerationType{
		HyperVGenerationTypeV1,
		HyperVGenerationTypeV2,
	}
}

func (c HyperVGenerationType) ToPtr() *HyperVGenerationType {
	return &c
}

// HyperVGenerationTypes - Specifies the HyperVGeneration Type
type HyperVGenerationTypes string

const (
	HyperVGenerationTypesV1 HyperVGenerationTypes = "V1"
	HyperVGenerationTypesV2 HyperVGenerationTypes = "V2"
)

func PossibleHyperVGenerationTypesValues() []HyperVGenerationTypes {
	return []HyperVGenerationTypes{
		HyperVGenerationTypesV1,
		HyperVGenerationTypesV2,
	}
}

func (c HyperVGenerationTypes) ToPtr() *HyperVGenerationTypes {
	return &c
}

// 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'.
type IPVersion string

const (
	IPVersionIPv4 IPVersion = "IPv4"
	IPVersionIPv6 IPVersion = "IPv6"
)

func PossibleIPVersionValues() []IPVersion {
	return []IPVersion{
		IPVersionIPv4,
		IPVersionIPv6,
	}
}

func (c IPVersion) ToPtr() *IPVersion {
	return &c
}

// InGuestPatchMode - Specifies the mode of in-guest patching to IaaS virtual machine.
// Possible values are:
// Manual - You control the application of patches to a virtual machine. You do this by applying patches manually inside the VM. In this mode, automatic
// updates are disabled; the property
// WindowsConfiguration.enableAutomaticUpdates must be false
// AutomaticByOS - The virtual machine will automatically be updated by the OS. The property WindowsConfiguration.enableAutomaticUpdates must be true.
// ** AutomaticByPlatform** - the virtual machine will automatically updated by the platform. The properties provisionVMAgent and WindowsConfiguration.enableAutomaticUpdates
// must be true
type InGuestPatchMode string

const (
	InGuestPatchModeAutomaticByOS       InGuestPatchMode = "AutomaticByOS"
	InGuestPatchModeAutomaticByPlatform InGuestPatchMode = "AutomaticByPlatform"
	InGuestPatchModeManual              InGuestPatchMode = "Manual"
)

func PossibleInGuestPatchModeValues() []InGuestPatchMode {
	return []InGuestPatchMode{
		InGuestPatchModeAutomaticByOS,
		InGuestPatchModeAutomaticByPlatform,
		InGuestPatchModeManual,
	}
}

func (c InGuestPatchMode) ToPtr() *InGuestPatchMode {
	return &c
}

// IntervalInMins - Interval value in minutes used to create LogAnalytics call rate logs.
type IntervalInMins string

const (
	IntervalInMinsThreeMins  IntervalInMins = "ThreeMins"
	IntervalInMinsFiveMins   IntervalInMins = "FiveMins"
	IntervalInMinsThirtyMins IntervalInMins = "ThirtyMins"
	IntervalInMinsSixtyMins  IntervalInMins = "SixtyMins"
)

func PossibleIntervalInMinsValues() []IntervalInMins {
	return []IntervalInMins{
		IntervalInMinsThreeMins,
		IntervalInMinsFiveMins,
		IntervalInMinsThirtyMins,
		IntervalInMinsSixtyMins,
	}
}

func (c IntervalInMins) ToPtr() *IntervalInMins {
	return &c
}

// MaintenanceOperationResultCodeTypes - The Last Maintenance Operation Result Code.
type MaintenanceOperationResultCodeTypes string

const (
	MaintenanceOperationResultCodeTypesNone                 MaintenanceOperationResultCodeTypes = "None"
	MaintenanceOperationResultCodeTypesRetryLater           MaintenanceOperationResultCodeTypes = "RetryLater"
	MaintenanceOperationResultCodeTypesMaintenanceAborted   MaintenanceOperationResultCodeTypes = "MaintenanceAborted"
	MaintenanceOperationResultCodeTypesMaintenanceCompleted MaintenanceOperationResultCodeTypes = "MaintenanceCompleted"
)

func PossibleMaintenanceOperationResultCodeTypesValues() []MaintenanceOperationResultCodeTypes {
	return []MaintenanceOperationResultCodeTypes{
		MaintenanceOperationResultCodeTypesNone,
		MaintenanceOperationResultCodeTypesRetryLater,
		MaintenanceOperationResultCodeTypesMaintenanceAborted,
		MaintenanceOperationResultCodeTypesMaintenanceCompleted,
	}
}

func (c MaintenanceOperationResultCodeTypes) ToPtr() *MaintenanceOperationResultCodeTypes {
	return &c
}

// NetworkAccessPolicy - Policy for accessing the disk via network.
type NetworkAccessPolicy string

const (
	// NetworkAccessPolicyAllowAll - The disk can be exported or uploaded to from any network.
	NetworkAccessPolicyAllowAll NetworkAccessPolicy = "AllowAll"
	// NetworkAccessPolicyAllowPrivate - The disk can be exported or uploaded to using a DiskAccess resource's private endpoints.
	NetworkAccessPolicyAllowPrivate NetworkAccessPolicy = "AllowPrivate"
	// NetworkAccessPolicyDenyAll - The disk cannot be exported.
	NetworkAccessPolicyDenyAll NetworkAccessPolicy = "DenyAll"
)

func PossibleNetworkAccessPolicyValues() []NetworkAccessPolicy {
	return []NetworkAccessPolicy{
		NetworkAccessPolicyAllowAll,
		NetworkAccessPolicyAllowPrivate,
		NetworkAccessPolicyDenyAll,
	}
}

func (c NetworkAccessPolicy) ToPtr() *NetworkAccessPolicy {
	return &c
}

// OperatingSystemStateTypes - The OS State.
type OperatingSystemStateTypes string

const (
	// OperatingSystemStateTypesGeneralized - Generalized image. Needs to be provisioned during deployment time.
	OperatingSystemStateTypesGeneralized OperatingSystemStateTypes = "Generalized"
	// OperatingSystemStateTypesSpecialized - Specialized image. Contains already provisioned OS Disk.
	OperatingSystemStateTypesSpecialized OperatingSystemStateTypes = "Specialized"
)

func PossibleOperatingSystemStateTypesValues() []OperatingSystemStateTypes {
	return []OperatingSystemStateTypes{
		OperatingSystemStateTypesGeneralized,
		OperatingSystemStateTypesSpecialized,
	}
}

func (c OperatingSystemStateTypes) ToPtr() *OperatingSystemStateTypes {
	return &c
}

// OperatingSystemTypes - The operating system of the osDiskImage.
type OperatingSystemTypes string

const (
	OperatingSystemTypesWindows OperatingSystemTypes = "Windows"
	OperatingSystemTypesLinux   OperatingSystemTypes = "Linux"
)

func PossibleOperatingSystemTypesValues() []OperatingSystemTypes {
	return []OperatingSystemTypes{
		OperatingSystemTypesWindows,
		OperatingSystemTypesLinux,
	}
}

func (c OperatingSystemTypes) ToPtr() *OperatingSystemTypes {
	return &c
}

// OrchestrationServiceNames - The name of the service.
type OrchestrationServiceNames string

const (
	OrchestrationServiceNamesAutomaticRepairs OrchestrationServiceNames = "AutomaticRepairs"
)

func PossibleOrchestrationServiceNamesValues() []OrchestrationServiceNames {
	return []OrchestrationServiceNames{
		OrchestrationServiceNamesAutomaticRepairs,
	}
}

func (c OrchestrationServiceNames) ToPtr() *OrchestrationServiceNames {
	return &c
}

// OrchestrationServiceState - The current state of the service.
type OrchestrationServiceState string

const (
	OrchestrationServiceStateNotRunning OrchestrationServiceState = "NotRunning"
	OrchestrationServiceStateRunning    OrchestrationServiceState = "Running"
	OrchestrationServiceStateSuspended  OrchestrationServiceState = "Suspended"
)

func PossibleOrchestrationServiceStateValues() []OrchestrationServiceState {
	return []OrchestrationServiceState{
		OrchestrationServiceStateNotRunning,
		OrchestrationServiceStateRunning,
		OrchestrationServiceStateSuspended,
	}
}

func (c OrchestrationServiceState) ToPtr() *OrchestrationServiceState {
	return &c
}

// OrchestrationServiceStateAction - The action to be performed.
type OrchestrationServiceStateAction string

const (
	OrchestrationServiceStateActionResume  OrchestrationServiceStateAction = "Resume"
	OrchestrationServiceStateActionSuspend OrchestrationServiceStateAction = "Suspend"
)

func PossibleOrchestrationServiceStateActionValues() []OrchestrationServiceStateAction {
	return []OrchestrationServiceStateAction{
		OrchestrationServiceStateActionResume,
		OrchestrationServiceStateActionSuspend,
	}
}

func (c OrchestrationServiceStateAction) ToPtr() *OrchestrationServiceStateAction {
	return &c
}

// PatchAssessmentState - Describes the outcome of an install operation for a given patch.
type PatchAssessmentState string

const (
	PatchAssessmentStateAvailable   PatchAssessmentState = "Available"
	PatchAssessmentStateExcluded    PatchAssessmentState = "Excluded"
	PatchAssessmentStateFailed      PatchAssessmentState = "Failed"
	PatchAssessmentStateInstalled   PatchAssessmentState = "Installed"
	PatchAssessmentStateNotSelected PatchAssessmentState = "NotSelected"
	PatchAssessmentStatePending     PatchAssessmentState = "Pending"
)

func PossiblePatchAssessmentStateValues() []PatchAssessmentState {
	return []PatchAssessmentState{
		PatchAssessmentStateAvailable,
		PatchAssessmentStateExcluded,
		PatchAssessmentStateFailed,
		PatchAssessmentStateInstalled,
		PatchAssessmentStateNotSelected,
		PatchAssessmentStatePending,
	}
}

func (c PatchAssessmentState) ToPtr() *PatchAssessmentState {
	return &c
}

// PatchOperationStatus - The overall success or failure status of the operation. It remains "InProgress" until the operation completes. At that point it
// will become "Failed", "Succeeded", or "CompletedWithWarnings."
type PatchOperationStatus string

const (
	PatchOperationStatusCompletedWithWarnings PatchOperationStatus = "CompletedWithWarnings"
	PatchOperationStatusFailed                PatchOperationStatus = "Failed"
	PatchOperationStatusInProgress            PatchOperationStatus = "InProgress"
	PatchOperationStatusSucceeded             PatchOperationStatus = "Succeeded"
)

func PossiblePatchOperationStatusValues() []PatchOperationStatus {
	return []PatchOperationStatus{
		PatchOperationStatusCompletedWithWarnings,
		PatchOperationStatusFailed,
		PatchOperationStatusInProgress,
		PatchOperationStatusSucceeded,
	}
}

func (c PatchOperationStatus) ToPtr() *PatchOperationStatus {
	return &c
}

// PrivateEndpointConnectionProvisioningState - The current provisioning state.
type PrivateEndpointConnectionProvisioningState string

const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState {
	return []PrivateEndpointConnectionProvisioningState{
		PrivateEndpointConnectionProvisioningStateCreating,
		PrivateEndpointConnectionProvisioningStateDeleting,
		PrivateEndpointConnectionProvisioningStateFailed,
		PrivateEndpointConnectionProvisioningStateSucceeded,
	}
}

func (c PrivateEndpointConnectionProvisioningState) ToPtr() *PrivateEndpointConnectionProvisioningState {
	return &c
}

// PrivateEndpointServiceConnectionStatus - The private endpoint connection status.
type PrivateEndpointServiceConnectionStatus string

const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus {
	return []PrivateEndpointServiceConnectionStatus{
		PrivateEndpointServiceConnectionStatusApproved,
		PrivateEndpointServiceConnectionStatusPending,
		PrivateEndpointServiceConnectionStatusRejected,
	}
}

func (c PrivateEndpointServiceConnectionStatus) ToPtr() *PrivateEndpointServiceConnectionStatus {
	return &c
}

// ProtocolTypes - Specifies the protocol of WinRM listener.
// Possible values are:
// http
// https
type ProtocolTypes string

const (
	ProtocolTypesHTTP  ProtocolTypes = "Http"
	ProtocolTypesHTTPs ProtocolTypes = "Https"
)

func PossibleProtocolTypesValues() []ProtocolTypes {
	return []ProtocolTypes{
		ProtocolTypesHTTP,
		ProtocolTypesHTTPs,
	}
}

func (c ProtocolTypes) ToPtr() *ProtocolTypes {
	return &c
}

// ProximityPlacementGroupType - Specifies the type of the proximity placement group.
// Possible values are:
// Standard : Co-locate resources within an Azure region or Availability Zone.
// Ultra : For future use.
type ProximityPlacementGroupType string

const (
	ProximityPlacementGroupTypeStandard ProximityPlacementGroupType = "Standard"
	ProximityPlacementGroupTypeUltra    ProximityPlacementGroupType = "Ultra"
)

func PossibleProximityPlacementGroupTypeValues() []ProximityPlacementGroupType {
	return []ProximityPlacementGroupType{
		ProximityPlacementGroupTypeStandard,
		ProximityPlacementGroupTypeUltra,
	}
}

func (c ProximityPlacementGroupType) ToPtr() *ProximityPlacementGroupType {
	return &c
}

// RebootStatus - The reboot status of the machine after the patch operation. It will be in "NotNeeded" status if reboot is not needed after the patch operation.
// "Required" will be the status once the patch is applied
// and machine is required to reboot. "Started" will be the reboot status when the machine has started to reboot. "Failed" will be the status if the machine
// is failed to reboot. "Completed" will be the
// status once the machine is rebooted successfully
type RebootStatus string

const (
	RebootStatusCompleted RebootStatus = "Completed"
	RebootStatusFailed    RebootStatus = "Failed"
	RebootStatusNotNeeded RebootStatus = "NotNeeded"
	RebootStatusRequired  RebootStatus = "Required"
	RebootStatusStarted   RebootStatus = "Started"
)

func PossibleRebootStatusValues() []RebootStatus {
	return []RebootStatus{
		RebootStatusCompleted,
		RebootStatusFailed,
		RebootStatusNotNeeded,
		RebootStatusRequired,
		RebootStatusStarted,
	}
}

func (c RebootStatus) ToPtr() *RebootStatus {
	return &c
}

// ReplicationState - This is the regional replication state.
type ReplicationState string

const (
	ReplicationStateCompleted   ReplicationState = "Completed"
	ReplicationStateFailed      ReplicationState = "Failed"
	ReplicationStateReplicating ReplicationState = "Replicating"
	ReplicationStateUnknown     ReplicationState = "Unknown"
)

func PossibleReplicationStateValues() []ReplicationState {
	return []ReplicationState{
		ReplicationStateCompleted,
		ReplicationStateFailed,
		ReplicationStateReplicating,
		ReplicationStateUnknown,
	}
}

func (c ReplicationState) ToPtr() *ReplicationState {
	return &c
}

type ReplicationStatusTypes string

const (
	ReplicationStatusTypesReplicationStatus ReplicationStatusTypes = "ReplicationStatus"
)

func PossibleReplicationStatusTypesValues() []ReplicationStatusTypes {
	return []ReplicationStatusTypes{
		ReplicationStatusTypesReplicationStatus,
	}
}

func (c ReplicationStatusTypes) ToPtr() *ReplicationStatusTypes {
	return &c
}

// 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.
type ResourceIDentityType string

const (
	ResourceIDentityTypeSystemAssigned             ResourceIDentityType = "SystemAssigned"
	ResourceIDentityTypeUserAssigned               ResourceIDentityType = "UserAssigned"
	ResourceIDentityTypeSystemAssignedUserAssigned ResourceIDentityType = "SystemAssigned, UserAssigned"
	ResourceIDentityTypeNone                       ResourceIDentityType = "None"
)

func PossibleResourceIDentityTypeValues() []ResourceIDentityType {
	return []ResourceIDentityType{
		ResourceIDentityTypeSystemAssigned,
		ResourceIDentityTypeUserAssigned,
		ResourceIDentityTypeSystemAssignedUserAssigned,
		ResourceIDentityTypeNone,
	}
}

func (c ResourceIDentityType) ToPtr() *ResourceIDentityType {
	return &c
}

// ResourceSKUCapacityScaleType - The scale type applicable to the sku.
type ResourceSKUCapacityScaleType string

const (
	ResourceSKUCapacityScaleTypeAutomatic ResourceSKUCapacityScaleType = "Automatic"
	ResourceSKUCapacityScaleTypeManual    ResourceSKUCapacityScaleType = "Manual"
	ResourceSKUCapacityScaleTypeNone      ResourceSKUCapacityScaleType = "None"
)

func PossibleResourceSKUCapacityScaleTypeValues() []ResourceSKUCapacityScaleType {
	return []ResourceSKUCapacityScaleType{
		ResourceSKUCapacityScaleTypeAutomatic,
		ResourceSKUCapacityScaleTypeManual,
		ResourceSKUCapacityScaleTypeNone,
	}
}

func (c ResourceSKUCapacityScaleType) ToPtr() *ResourceSKUCapacityScaleType {
	return &c
}

// ResourceSKURestrictionsReasonCode - The reason for restriction.
type ResourceSKURestrictionsReasonCode string

const (
	ResourceSKURestrictionsReasonCodeQuotaID                     ResourceSKURestrictionsReasonCode = "QuotaId"
	ResourceSKURestrictionsReasonCodeNotAvailableForSubscription ResourceSKURestrictionsReasonCode = "NotAvailableForSubscription"
)

func PossibleResourceSKURestrictionsReasonCodeValues() []ResourceSKURestrictionsReasonCode {
	return []ResourceSKURestrictionsReasonCode{
		ResourceSKURestrictionsReasonCodeQuotaID,
		ResourceSKURestrictionsReasonCodeNotAvailableForSubscription,
	}
}

func (c ResourceSKURestrictionsReasonCode) ToPtr() *ResourceSKURestrictionsReasonCode {
	return &c
}

// ResourceSKURestrictionsType - The type of restrictions.
type ResourceSKURestrictionsType string

const (
	ResourceSKURestrictionsTypeLocation ResourceSKURestrictionsType = "Location"
	ResourceSKURestrictionsTypeZone     ResourceSKURestrictionsType = "Zone"
)

func PossibleResourceSKURestrictionsTypeValues() []ResourceSKURestrictionsType {
	return []ResourceSKURestrictionsType{
		ResourceSKURestrictionsTypeLocation,
		ResourceSKURestrictionsTypeZone,
	}
}

func (c ResourceSKURestrictionsType) ToPtr() *ResourceSKURestrictionsType {
	return &c
}

// RollingUpgradeActionType - The last action performed on the rolling upgrade.
type RollingUpgradeActionType string

const (
	RollingUpgradeActionTypeStart  RollingUpgradeActionType = "Start"
	RollingUpgradeActionTypeCancel RollingUpgradeActionType = "Cancel"
)

func PossibleRollingUpgradeActionTypeValues() []RollingUpgradeActionType {
	return []RollingUpgradeActionType{
		RollingUpgradeActionTypeStart,
		RollingUpgradeActionTypeCancel,
	}
}

func (c RollingUpgradeActionType) ToPtr() *RollingUpgradeActionType {
	return &c
}

// RollingUpgradeStatusCode - Code indicating the current status of the upgrade.
type RollingUpgradeStatusCode string

const (
	RollingUpgradeStatusCodeRollingForward RollingUpgradeStatusCode = "RollingForward"
	RollingUpgradeStatusCodeCancelled      RollingUpgradeStatusCode = "Cancelled"
	RollingUpgradeStatusCodeCompleted      RollingUpgradeStatusCode = "Completed"
	RollingUpgradeStatusCodeFaulted        RollingUpgradeStatusCode = "Faulted"
)

func PossibleRollingUpgradeStatusCodeValues() []RollingUpgradeStatusCode {
	return []RollingUpgradeStatusCode{
		RollingUpgradeStatusCodeRollingForward,
		RollingUpgradeStatusCodeCancelled,
		RollingUpgradeStatusCodeCompleted,
		RollingUpgradeStatusCodeFaulted,
	}
}

func (c RollingUpgradeStatusCode) ToPtr() *RollingUpgradeStatusCode {
	return &c
}

type SelectPermissions string

const (
	SelectPermissionsPermissions SelectPermissions = "Permissions"
)

func PossibleSelectPermissionsValues() []SelectPermissions {
	return []SelectPermissions{
		SelectPermissionsPermissions,
	}
}

func (c SelectPermissions) ToPtr() *SelectPermissions {
	return &c
}

// SettingNames - Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon.
type SettingNames string

const (
	SettingNamesAutoLogon          SettingNames = "AutoLogon"
	SettingNamesFirstLogonCommands SettingNames = "FirstLogonCommands"
)

func PossibleSettingNamesValues() []SettingNames {
	return []SettingNames{
		SettingNamesAutoLogon,
		SettingNamesFirstLogonCommands,
	}
}

func (c SettingNames) ToPtr() *SettingNames {
	return &c
}

type SharedToValues string

const (
	SharedToValuesTenant SharedToValues = "tenant"
)

func PossibleSharedToValuesValues() []SharedToValues {
	return []SharedToValues{
		SharedToValuesTenant,
	}
}

func (c SharedToValues) ToPtr() *SharedToValues {
	return &c
}

// SharingProfileGroupTypes - This property allows you to specify the type of sharing group.
// Possible values are:
// Subscriptions
// AADTenants
type SharingProfileGroupTypes string

const (
	SharingProfileGroupTypesAadTenants    SharingProfileGroupTypes = "AADTenants"
	SharingProfileGroupTypesSubscriptions SharingProfileGroupTypes = "Subscriptions"
)

func PossibleSharingProfileGroupTypesValues() []SharingProfileGroupTypes {
	return []SharingProfileGroupTypes{
		SharingProfileGroupTypesAadTenants,
		SharingProfileGroupTypesSubscriptions,
	}
}

func (c SharingProfileGroupTypes) ToPtr() *SharingProfileGroupTypes {
	return &c
}

// SharingUpdateOperationTypes - This property allows you to specify the operation type of gallery sharing update.
// Possible values are:
// Add
// Remove
// Reset
type SharingUpdateOperationTypes string

const (
	SharingUpdateOperationTypesAdd    SharingUpdateOperationTypes = "Add"
	SharingUpdateOperationTypesRemove SharingUpdateOperationTypes = "Remove"
	SharingUpdateOperationTypesReset  SharingUpdateOperationTypes = "Reset"
)

func PossibleSharingUpdateOperationTypesValues() []SharingUpdateOperationTypes {
	return []SharingUpdateOperationTypes{
		SharingUpdateOperationTypesAdd,
		SharingUpdateOperationTypesRemove,
		SharingUpdateOperationTypesReset,
	}
}

func (c SharingUpdateOperationTypes) ToPtr() *SharingUpdateOperationTypes {
	return &c
}

// SnapshotStorageAccountTypes - The sku name.
type SnapshotStorageAccountTypes string

const (
	// SnapshotStorageAccountTypesPremiumLrs - Premium SSD locally redundant storage
	SnapshotStorageAccountTypesPremiumLrs SnapshotStorageAccountTypes = "Premium_LRS"
	// SnapshotStorageAccountTypesStandardLrs - Standard HDD locally redundant storage
	SnapshotStorageAccountTypesStandardLrs SnapshotStorageAccountTypes = "Standard_LRS"
	// SnapshotStorageAccountTypesStandardZrs - Standard zone redundant storage
	SnapshotStorageAccountTypesStandardZrs SnapshotStorageAccountTypes = "Standard_ZRS"
)

func PossibleSnapshotStorageAccountTypesValues() []SnapshotStorageAccountTypes {
	return []SnapshotStorageAccountTypes{
		SnapshotStorageAccountTypesPremiumLrs,
		SnapshotStorageAccountTypesStandardLrs,
		SnapshotStorageAccountTypesStandardZrs,
	}
}

func (c SnapshotStorageAccountTypes) ToPtr() *SnapshotStorageAccountTypes {
	return &c
}

// SoftwareUpdateRebootBehavior - Describes the reboot requirements of the patch.
type SoftwareUpdateRebootBehavior string

const (
	SoftwareUpdateRebootBehaviorAlwaysRequiresReboot SoftwareUpdateRebootBehavior = "AlwaysRequiresReboot"
	SoftwareUpdateRebootBehaviorCanRequestReboot     SoftwareUpdateRebootBehavior = "CanRequestReboot"
	SoftwareUpdateRebootBehaviorNeverReboots         SoftwareUpdateRebootBehavior = "NeverReboots"
)

func PossibleSoftwareUpdateRebootBehaviorValues() []SoftwareUpdateRebootBehavior {
	return []SoftwareUpdateRebootBehavior{
		SoftwareUpdateRebootBehaviorAlwaysRequiresReboot,
		SoftwareUpdateRebootBehaviorCanRequestReboot,
		SoftwareUpdateRebootBehaviorNeverReboots,
	}
}

func (c SoftwareUpdateRebootBehavior) ToPtr() *SoftwareUpdateRebootBehavior {
	return &c
}

// StatusLevelTypes - The level code.
type StatusLevelTypes string

const (
	StatusLevelTypesInfo    StatusLevelTypes = "Info"
	StatusLevelTypesWarning StatusLevelTypes = "Warning"
	StatusLevelTypesError   StatusLevelTypes = "Error"
)

func PossibleStatusLevelTypesValues() []StatusLevelTypes {
	return []StatusLevelTypes{
		StatusLevelTypesInfo,
		StatusLevelTypesWarning,
		StatusLevelTypesError,
	}
}

func (c StatusLevelTypes) ToPtr() *StatusLevelTypes {
	return &c
}

// StorageAccountType - Specifies the storage account type to be used to store the image. This property is not updatable.
type StorageAccountType string

const (
	StorageAccountTypePremiumLrs  StorageAccountType = "Premium_LRS"
	StorageAccountTypeStandardLrs StorageAccountType = "Standard_LRS"
	StorageAccountTypeStandardZrs StorageAccountType = "Standard_ZRS"
)

func PossibleStorageAccountTypeValues() []StorageAccountType {
	return []StorageAccountType{
		StorageAccountTypePremiumLrs,
		StorageAccountTypeStandardLrs,
		StorageAccountTypeStandardZrs,
	}
}

func (c StorageAccountType) ToPtr() *StorageAccountType {
	return &c
}

// 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: UltraSSDLRS can only be used with data disks. It
// cannot be used with OS Disk. StandardLRS uses Standard HDD. StandardSSDLRS uses Standard SSD. PremiumLRS uses Premium SSD. UltraSSD_LRS uses Ultra disk.
// For more information regarding disks supported
// for Windows Virtual Machines, refer to https://docs.microsoft.com/en-us/azure/virtual-machines/windows/disks-types and, for Linux Virtual Machines, refer
// to
// https://docs.microsoft.com/en-us/azure/virtual-machines/linux/disks-types
type StorageAccountTypes string

const (
	StorageAccountTypesPremiumLrs     StorageAccountTypes = "Premium_LRS"
	StorageAccountTypesStandardLrs    StorageAccountTypes = "Standard_LRS"
	StorageAccountTypesStandardSsdlrs StorageAccountTypes = "StandardSSD_LRS"
	StorageAccountTypesUltraSsdlrs    StorageAccountTypes = "UltraSSD_LRS"
)

func PossibleStorageAccountTypesValues() []StorageAccountTypes {
	return []StorageAccountTypes{
		StorageAccountTypesPremiumLrs,
		StorageAccountTypesStandardLrs,
		StorageAccountTypesStandardSsdlrs,
		StorageAccountTypesUltraSsdlrs,
	}
}

func (c StorageAccountTypes) ToPtr() *StorageAccountTypes {
	return &c
}

// UpgradeMode - Specifies the mode of an upgrade to virtual machines in the scale set.
// Possible values are:
// Manual - You control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.
// Automatic - All virtual machines in the scale set are automatically updated at the same time.
type UpgradeMode string

const (
	UpgradeModeAutomatic UpgradeMode = "Automatic"
	UpgradeModeManual    UpgradeMode = "Manual"
	UpgradeModeRolling   UpgradeMode = "Rolling"
)

func PossibleUpgradeModeValues() []UpgradeMode {
	return []UpgradeMode{
		UpgradeModeAutomatic,
		UpgradeModeManual,
		UpgradeModeRolling,
	}
}

func (c UpgradeMode) ToPtr() *UpgradeMode {
	return &c
}

// UpgradeOperationInvoker - Invoker of the Upgrade Operation
type UpgradeOperationInvoker string

const (
	UpgradeOperationInvokerUnknown  UpgradeOperationInvoker = "Unknown"
	UpgradeOperationInvokerUser     UpgradeOperationInvoker = "User"
	UpgradeOperationInvokerPlatform UpgradeOperationInvoker = "Platform"
)

func PossibleUpgradeOperationInvokerValues() []UpgradeOperationInvoker {
	return []UpgradeOperationInvoker{
		UpgradeOperationInvokerUnknown,
		UpgradeOperationInvokerUser,
		UpgradeOperationInvokerPlatform,
	}
}

func (c UpgradeOperationInvoker) ToPtr() *UpgradeOperationInvoker {
	return &c
}

// UpgradeState - Code indicating the current status of the upgrade.
type UpgradeState string

const (
	UpgradeStateRollingForward UpgradeState = "RollingForward"
	UpgradeStateCancelled      UpgradeState = "Cancelled"
	UpgradeStateCompleted      UpgradeState = "Completed"
	UpgradeStateFaulted        UpgradeState = "Faulted"
)

func PossibleUpgradeStateValues() []UpgradeState {
	return []UpgradeState{
		UpgradeStateRollingForward,
		UpgradeStateCancelled,
		UpgradeStateCompleted,
		UpgradeStateFaulted,
	}
}

func (c UpgradeState) ToPtr() *UpgradeState {
	return &c
}

// VMDiskTypes - VM disk types which are disallowed.
type VMDiskTypes string

const (
	VMDiskTypesNone      VMDiskTypes = "None"
	VMDiskTypesUnmanaged VMDiskTypes = "Unmanaged"
)

func PossibleVMDiskTypesValues() []VMDiskTypes {
	return []VMDiskTypes{
		VMDiskTypesNone,
		VMDiskTypesUnmanaged,
	}
}

func (c VMDiskTypes) ToPtr() *VMDiskTypes {
	return &c
}

// VirtualMachineEvictionPolicyTypes - Specifies the eviction policy for the Azure Spot VM/VMSS
type VirtualMachineEvictionPolicyTypes string

const (
	VirtualMachineEvictionPolicyTypesDeallocate VirtualMachineEvictionPolicyTypes = "Deallocate"
	VirtualMachineEvictionPolicyTypesDelete     VirtualMachineEvictionPolicyTypes = "Delete"
)

func PossibleVirtualMachineEvictionPolicyTypesValues() []VirtualMachineEvictionPolicyTypes {
	return []VirtualMachineEvictionPolicyTypes{
		VirtualMachineEvictionPolicyTypesDeallocate,
		VirtualMachineEvictionPolicyTypesDelete,
	}
}

func (c VirtualMachineEvictionPolicyTypes) ToPtr() *VirtualMachineEvictionPolicyTypes {
	return &c
}

// VirtualMachinePriorityTypes - Specifies the priority for a standalone virtual machine or the virtual machines in the scale set.
// 'Low' enum will be deprecated in the future, please use 'Spot' as the enum to deploy Azure Spot VM/VMSS.
type VirtualMachinePriorityTypes string

const (
	VirtualMachinePriorityTypesLow     VirtualMachinePriorityTypes = "Low"
	VirtualMachinePriorityTypesRegular VirtualMachinePriorityTypes = "Regular"
	VirtualMachinePriorityTypesSpot    VirtualMachinePriorityTypes = "Spot"
)

func PossibleVirtualMachinePriorityTypesValues() []VirtualMachinePriorityTypes {
	return []VirtualMachinePriorityTypes{
		VirtualMachinePriorityTypesLow,
		VirtualMachinePriorityTypesRegular,
		VirtualMachinePriorityTypesSpot,
	}
}

func (c VirtualMachinePriorityTypes) ToPtr() *VirtualMachinePriorityTypes {
	return &c
}

// VirtualMachineScaleSetSKUScaleType - The scale type applicable to the sku.
type VirtualMachineScaleSetSKUScaleType string

const (
	VirtualMachineScaleSetSKUScaleTypeAutomatic VirtualMachineScaleSetSKUScaleType = "Automatic"
	VirtualMachineScaleSetSKUScaleTypeNone      VirtualMachineScaleSetSKUScaleType = "None"
)

func PossibleVirtualMachineScaleSetSKUScaleTypeValues() []VirtualMachineScaleSetSKUScaleType {
	return []VirtualMachineScaleSetSKUScaleType{
		VirtualMachineScaleSetSKUScaleTypeAutomatic,
		VirtualMachineScaleSetSKUScaleTypeNone,
	}
}

func (c VirtualMachineScaleSetSKUScaleType) ToPtr() *VirtualMachineScaleSetSKUScaleType {
	return &c
}

type VirtualMachineScaleSetScaleInRules string

const (
	VirtualMachineScaleSetScaleInRulesDefault  VirtualMachineScaleSetScaleInRules = "Default"
	VirtualMachineScaleSetScaleInRulesNewestVM VirtualMachineScaleSetScaleInRules = "NewestVM"
	VirtualMachineScaleSetScaleInRulesOldestVM VirtualMachineScaleSetScaleInRules = "OldestVM"
)

func PossibleVirtualMachineScaleSetScaleInRulesValues() []VirtualMachineScaleSetScaleInRules {
	return []VirtualMachineScaleSetScaleInRules{
		VirtualMachineScaleSetScaleInRulesDefault,
		VirtualMachineScaleSetScaleInRulesNewestVM,
		VirtualMachineScaleSetScaleInRulesOldestVM,
	}
}

func (c VirtualMachineScaleSetScaleInRules) ToPtr() *VirtualMachineScaleSetScaleInRules {
	return &c
}

// VirtualMachineSizeTypes - Specifies the size of the virtual machine. For more information about virtual machine sizes, see Sizes for virtual machines
// [https://docs.microsoft.com/en-us/azure/virtual-machines/sizes].
// The available VM sizes depend on region and availability set. For a list of available sizes use these APIs:
// List all available virtual machine sizes in an availability set [https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes]
// List all available virtual machine sizes in a region [https://docs.microsoft.com/en-us/rest/api/compute/resourceskus/list]
// List all available virtual machine sizes for resizing [https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes].
// This list of sizes is no longer updated and the VirtualMachineSizeTypes string constants will be removed from the subsequent REST API specification.
// Use List all available virtual machine sizes in a
// region [https://docs.microsoft.com/en-us/rest/api/compute/resourceskus/list] to get the latest sizes.
type VirtualMachineSizeTypes string

const (
	VirtualMachineSizeTypesBasicA0          VirtualMachineSizeTypes = "Basic_A0"
	VirtualMachineSizeTypesBasicA1          VirtualMachineSizeTypes = "Basic_A1"
	VirtualMachineSizeTypesBasicA2          VirtualMachineSizeTypes = "Basic_A2"
	VirtualMachineSizeTypesBasicA3          VirtualMachineSizeTypes = "Basic_A3"
	VirtualMachineSizeTypesBasicA4          VirtualMachineSizeTypes = "Basic_A4"
	VirtualMachineSizeTypesStandardA0       VirtualMachineSizeTypes = "Standard_A0"
	VirtualMachineSizeTypesStandardA1       VirtualMachineSizeTypes = "Standard_A1"
	VirtualMachineSizeTypesStandardA10      VirtualMachineSizeTypes = "Standard_A10"
	VirtualMachineSizeTypesStandardA11      VirtualMachineSizeTypes = "Standard_A11"
	VirtualMachineSizeTypesStandardA1V2     VirtualMachineSizeTypes = "Standard_A1_v2"
	VirtualMachineSizeTypesStandardA2       VirtualMachineSizeTypes = "Standard_A2"
	VirtualMachineSizeTypesStandardA2Mv2    VirtualMachineSizeTypes = "Standard_A2m_v2"
	VirtualMachineSizeTypesStandardA2V2     VirtualMachineSizeTypes = "Standard_A2_v2"
	VirtualMachineSizeTypesStandardA3       VirtualMachineSizeTypes = "Standard_A3"
	VirtualMachineSizeTypesStandardA4       VirtualMachineSizeTypes = "Standard_A4"
	VirtualMachineSizeTypesStandardA4Mv2    VirtualMachineSizeTypes = "Standard_A4m_v2"
	VirtualMachineSizeTypesStandardA4V2     VirtualMachineSizeTypes = "Standard_A4_v2"
	VirtualMachineSizeTypesStandardA5       VirtualMachineSizeTypes = "Standard_A5"
	VirtualMachineSizeTypesStandardA6       VirtualMachineSizeTypes = "Standard_A6"
	VirtualMachineSizeTypesStandardA7       VirtualMachineSizeTypes = "Standard_A7"
	VirtualMachineSizeTypesStandardA8       VirtualMachineSizeTypes = "Standard_A8"
	VirtualMachineSizeTypesStandardA8Mv2    VirtualMachineSizeTypes = "Standard_A8m_v2"
	VirtualMachineSizeTypesStandardA8V2     VirtualMachineSizeTypes = "Standard_A8_v2"
	VirtualMachineSizeTypesStandardA9       VirtualMachineSizeTypes = "Standard_A9"
	VirtualMachineSizeTypesStandardB1MS     VirtualMachineSizeTypes = "Standard_B1ms"
	VirtualMachineSizeTypesStandardB1S      VirtualMachineSizeTypes = "Standard_B1s"
	VirtualMachineSizeTypesStandardB2MS     VirtualMachineSizeTypes = "Standard_B2ms"
	VirtualMachineSizeTypesStandardB2S      VirtualMachineSizeTypes = "Standard_B2s"
	VirtualMachineSizeTypesStandardB4MS     VirtualMachineSizeTypes = "Standard_B4ms"
	VirtualMachineSizeTypesStandardB8MS     VirtualMachineSizeTypes = "Standard_B8ms"
	VirtualMachineSizeTypesStandardD1       VirtualMachineSizeTypes = "Standard_D1"
	VirtualMachineSizeTypesStandardD11      VirtualMachineSizeTypes = "Standard_D11"
	VirtualMachineSizeTypesStandardD11V2    VirtualMachineSizeTypes = "Standard_D11_v2"
	VirtualMachineSizeTypesStandardD12      VirtualMachineSizeTypes = "Standard_D12"
	VirtualMachineSizeTypesStandardD12V2    VirtualMachineSizeTypes = "Standard_D12_v2"
	VirtualMachineSizeTypesStandardD13      VirtualMachineSizeTypes = "Standard_D13"
	VirtualMachineSizeTypesStandardD13V2    VirtualMachineSizeTypes = "Standard_D13_v2"
	VirtualMachineSizeTypesStandardD14      VirtualMachineSizeTypes = "Standard_D14"
	VirtualMachineSizeTypesStandardD14V2    VirtualMachineSizeTypes = "Standard_D14_v2"
	VirtualMachineSizeTypesStandardD15V2    VirtualMachineSizeTypes = "Standard_D15_v2"
	VirtualMachineSizeTypesStandardD16Sv3   VirtualMachineSizeTypes = "Standard_D16s_v3"
	VirtualMachineSizeTypesStandardD16V3    VirtualMachineSizeTypes = "Standard_D16_v3"
	VirtualMachineSizeTypesStandardD1V2     VirtualMachineSizeTypes = "Standard_D1_v2"
	VirtualMachineSizeTypesStandardD2       VirtualMachineSizeTypes = "Standard_D2"
	VirtualMachineSizeTypesStandardD2Sv3    VirtualMachineSizeTypes = "Standard_D2s_v3"
	VirtualMachineSizeTypesStandardD2V2     VirtualMachineSizeTypes = "Standard_D2_v2"
	VirtualMachineSizeTypesStandardD2V3     VirtualMachineSizeTypes = "Standard_D2_v3"
	VirtualMachineSizeTypesStandardD3       VirtualMachineSizeTypes = "Standard_D3"
	VirtualMachineSizeTypesStandardD32Sv3   VirtualMachineSizeTypes = "Standard_D32s_v3"
	VirtualMachineSizeTypesStandardD32V3    VirtualMachineSizeTypes = "Standard_D32_v3"
	VirtualMachineSizeTypesStandardD3V2     VirtualMachineSizeTypes = "Standard_D3_v2"
	VirtualMachineSizeTypesStandardD4       VirtualMachineSizeTypes = "Standard_D4"
	VirtualMachineSizeTypesStandardD4Sv3    VirtualMachineSizeTypes = "Standard_D4s_v3"
	VirtualMachineSizeTypesStandardD4V2     VirtualMachineSizeTypes = "Standard_D4_v2"
	VirtualMachineSizeTypesStandardD4V3     VirtualMachineSizeTypes = "Standard_D4_v3"
	VirtualMachineSizeTypesStandardD5V2     VirtualMachineSizeTypes = "Standard_D5_v2"
	VirtualMachineSizeTypesStandardD64Sv3   VirtualMachineSizeTypes = "Standard_D64s_v3"
	VirtualMachineSizeTypesStandardD64V3    VirtualMachineSizeTypes = "Standard_D64_v3"
	VirtualMachineSizeTypesStandardD8Sv3    VirtualMachineSizeTypes = "Standard_D8s_v3"
	VirtualMachineSizeTypesStandardD8V3     VirtualMachineSizeTypes = "Standard_D8_v3"
	VirtualMachineSizeTypesStandardDs1      VirtualMachineSizeTypes = "Standard_DS1"
	VirtualMachineSizeTypesStandardDs11     VirtualMachineSizeTypes = "Standard_DS11"
	VirtualMachineSizeTypesStandardDs11V2   VirtualMachineSizeTypes = "Standard_DS11_v2"
	VirtualMachineSizeTypesStandardDs12     VirtualMachineSizeTypes = "Standard_DS12"
	VirtualMachineSizeTypesStandardDs12V2   VirtualMachineSizeTypes = "Standard_DS12_v2"
	VirtualMachineSizeTypesStandardDs13     VirtualMachineSizeTypes = "Standard_DS13"
	VirtualMachineSizeTypesStandardDs132V2  VirtualMachineSizeTypes = "Standard_DS13-2_v2"
	VirtualMachineSizeTypesStandardDs134V2  VirtualMachineSizeTypes = "Standard_DS13-4_v2"
	VirtualMachineSizeTypesStandardDs13V2   VirtualMachineSizeTypes = "Standard_DS13_v2"
	VirtualMachineSizeTypesStandardDs14     VirtualMachineSizeTypes = "Standard_DS14"
	VirtualMachineSizeTypesStandardDs144V2  VirtualMachineSizeTypes = "Standard_DS14-4_v2"
	VirtualMachineSizeTypesStandardDs148V2  VirtualMachineSizeTypes = "Standard_DS14-8_v2"
	VirtualMachineSizeTypesStandardDs14V2   VirtualMachineSizeTypes = "Standard_DS14_v2"
	VirtualMachineSizeTypesStandardDs15V2   VirtualMachineSizeTypes = "Standard_DS15_v2"
	VirtualMachineSizeTypesStandardDs1V2    VirtualMachineSizeTypes = "Standard_DS1_v2"
	VirtualMachineSizeTypesStandardDs2      VirtualMachineSizeTypes = "Standard_DS2"
	VirtualMachineSizeTypesStandardDs2V2    VirtualMachineSizeTypes = "Standard_DS2_v2"
	VirtualMachineSizeTypesStandardDs3      VirtualMachineSizeTypes = "Standard_DS3"
	VirtualMachineSizeTypesStandardDs3V2    VirtualMachineSizeTypes = "Standard_DS3_v2"
	VirtualMachineSizeTypesStandardDs4      VirtualMachineSizeTypes = "Standard_DS4"
	VirtualMachineSizeTypesStandardDs4V2    VirtualMachineSizeTypes = "Standard_DS4_v2"
	VirtualMachineSizeTypesStandardDs5V2    VirtualMachineSizeTypes = "Standard_DS5_v2"
	VirtualMachineSizeTypesStandardE16Sv3   VirtualMachineSizeTypes = "Standard_E16s_v3"
	VirtualMachineSizeTypesStandardE16V3    VirtualMachineSizeTypes = "Standard_E16_v3"
	VirtualMachineSizeTypesStandardE2Sv3    VirtualMachineSizeTypes = "Standard_E2s_v3"
	VirtualMachineSizeTypesStandardE2V3     VirtualMachineSizeTypes = "Standard_E2_v3"
	VirtualMachineSizeTypesStandardE3216V3  VirtualMachineSizeTypes = "Standard_E32-16_v3"
	VirtualMachineSizeTypesStandardE328Sv3  VirtualMachineSizeTypes = "Standard_E32-8s_v3"
	VirtualMachineSizeTypesStandardE32Sv3   VirtualMachineSizeTypes = "Standard_E32s_v3"
	VirtualMachineSizeTypesStandardE32V3    VirtualMachineSizeTypes = "Standard_E32_v3"
	VirtualMachineSizeTypesStandardE4Sv3    VirtualMachineSizeTypes = "Standard_E4s_v3"
	VirtualMachineSizeTypesStandardE4V3     VirtualMachineSizeTypes = "Standard_E4_v3"
	VirtualMachineSizeTypesStandardE6416Sv3 VirtualMachineSizeTypes = "Standard_E64-16s_v3"
	VirtualMachineSizeTypesStandardE6432Sv3 VirtualMachineSizeTypes = "Standard_E64-32s_v3"
	VirtualMachineSizeTypesStandardE64Sv3   VirtualMachineSizeTypes = "Standard_E64s_v3"
	VirtualMachineSizeTypesStandardE64V3    VirtualMachineSizeTypes = "Standard_E64_v3"
	VirtualMachineSizeTypesStandardE8Sv3    VirtualMachineSizeTypes = "Standard_E8s_v3"
	VirtualMachineSizeTypesStandardE8V3     VirtualMachineSizeTypes = "Standard_E8_v3"
	VirtualMachineSizeTypesStandardF1       VirtualMachineSizeTypes = "Standard_F1"
	VirtualMachineSizeTypesStandardF16      VirtualMachineSizeTypes = "Standard_F16"
	VirtualMachineSizeTypesStandardF16S     VirtualMachineSizeTypes = "Standard_F16s"
	VirtualMachineSizeTypesStandardF16Sv2   VirtualMachineSizeTypes = "Standard_F16s_v2"
	VirtualMachineSizeTypesStandardF1S      VirtualMachineSizeTypes = "Standard_F1s"
	VirtualMachineSizeTypesStandardF2       VirtualMachineSizeTypes = "Standard_F2"
	VirtualMachineSizeTypesStandardF2S      VirtualMachineSizeTypes = "Standard_F2s"
	VirtualMachineSizeTypesStandardF2Sv2    VirtualMachineSizeTypes = "Standard_F2s_v2"
	VirtualMachineSizeTypesStandardF32Sv2   VirtualMachineSizeTypes = "Standard_F32s_v2"
	VirtualMachineSizeTypesStandardF4       VirtualMachineSizeTypes = "Standard_F4"
	VirtualMachineSizeTypesStandardF4S      VirtualMachineSizeTypes = "Standard_F4s"
	VirtualMachineSizeTypesStandardF4Sv2    VirtualMachineSizeTypes = "Standard_F4s_v2"
	VirtualMachineSizeTypesStandardF64Sv2   VirtualMachineSizeTypes = "Standard_F64s_v2"
	VirtualMachineSizeTypesStandardF72Sv2   VirtualMachineSizeTypes = "Standard_F72s_v2"
	VirtualMachineSizeTypesStandardF8       VirtualMachineSizeTypes = "Standard_F8"
	VirtualMachineSizeTypesStandardF8S      VirtualMachineSizeTypes = "Standard_F8s"
	VirtualMachineSizeTypesStandardF8Sv2    VirtualMachineSizeTypes = "Standard_F8s_v2"
	VirtualMachineSizeTypesStandardG1       VirtualMachineSizeTypes = "Standard_G1"
	VirtualMachineSizeTypesStandardG2       VirtualMachineSizeTypes = "Standard_G2"
	VirtualMachineSizeTypesStandardG3       VirtualMachineSizeTypes = "Standard_G3"
	VirtualMachineSizeTypesStandardG4       VirtualMachineSizeTypes = "Standard_G4"
	VirtualMachineSizeTypesStandardG5       VirtualMachineSizeTypes = "Standard_G5"
	VirtualMachineSizeTypesStandardGs1      VirtualMachineSizeTypes = "Standard_GS1"
	VirtualMachineSizeTypesStandardGs2      VirtualMachineSizeTypes = "Standard_GS2"
	VirtualMachineSizeTypesStandardGs3      VirtualMachineSizeTypes = "Standard_GS3"
	VirtualMachineSizeTypesStandardGs4      VirtualMachineSizeTypes = "Standard_GS4"
	VirtualMachineSizeTypesStandardGs44     VirtualMachineSizeTypes = "Standard_GS4-4"
	VirtualMachineSizeTypesStandardGs48     VirtualMachineSizeTypes = "Standard_GS4-8"
	VirtualMachineSizeTypesStandardGs5      VirtualMachineSizeTypes = "Standard_GS5"
	VirtualMachineSizeTypesStandardGs516    VirtualMachineSizeTypes = "Standard_GS5-16"
	VirtualMachineSizeTypesStandardGs58     VirtualMachineSizeTypes = "Standard_GS5-8"
	VirtualMachineSizeTypesStandardH16      VirtualMachineSizeTypes = "Standard_H16"
	VirtualMachineSizeTypesStandardH16M     VirtualMachineSizeTypes = "Standard_H16m"
	VirtualMachineSizeTypesStandardH16Mr    VirtualMachineSizeTypes = "Standard_H16mr"
	VirtualMachineSizeTypesStandardH16R     VirtualMachineSizeTypes = "Standard_H16r"
	VirtualMachineSizeTypesStandardH8       VirtualMachineSizeTypes = "Standard_H8"
	VirtualMachineSizeTypesStandardH8M      VirtualMachineSizeTypes = "Standard_H8m"
	VirtualMachineSizeTypesStandardL16S     VirtualMachineSizeTypes = "Standard_L16s"
	VirtualMachineSizeTypesStandardL32S     VirtualMachineSizeTypes = "Standard_L32s"
	VirtualMachineSizeTypesStandardL4S      VirtualMachineSizeTypes = "Standard_L4s"
	VirtualMachineSizeTypesStandardL8S      VirtualMachineSizeTypes = "Standard_L8s"
	VirtualMachineSizeTypesStandardM12832MS VirtualMachineSizeTypes = "Standard_M128-32ms"
	VirtualMachineSizeTypesStandardM12864MS VirtualMachineSizeTypes = "Standard_M128-64ms"
	VirtualMachineSizeTypesStandardM128MS   VirtualMachineSizeTypes = "Standard_M128ms"
	VirtualMachineSizeTypesStandardM128S    VirtualMachineSizeTypes = "Standard_M128s"
	VirtualMachineSizeTypesStandardM6416MS  VirtualMachineSizeTypes = "Standard_M64-16ms"
	VirtualMachineSizeTypesStandardM6432MS  VirtualMachineSizeTypes = "Standard_M64-32ms"
	VirtualMachineSizeTypesStandardM64MS    VirtualMachineSizeTypes = "Standard_M64ms"
	VirtualMachineSizeTypesStandardM64S     VirtualMachineSizeTypes = "Standard_M64s"
	VirtualMachineSizeTypesStandardNc12     VirtualMachineSizeTypes = "Standard_NC12"
	VirtualMachineSizeTypesStandardNc12Sv2  VirtualMachineSizeTypes = "Standard_NC12s_v2"
	VirtualMachineSizeTypesStandardNc12Sv3  VirtualMachineSizeTypes = "Standard_NC12s_v3"
	VirtualMachineSizeTypesStandardNc24     VirtualMachineSizeTypes = "Standard_NC24"
	VirtualMachineSizeTypesStandardNc24R    VirtualMachineSizeTypes = "Standard_NC24r"
	VirtualMachineSizeTypesStandardNc24RsV2 VirtualMachineSizeTypes = "Standard_NC24rs_v2"
	VirtualMachineSizeTypesStandardNc24RsV3 VirtualMachineSizeTypes = "Standard_NC24rs_v3"
	VirtualMachineSizeTypesStandardNc24Sv2  VirtualMachineSizeTypes = "Standard_NC24s_v2"
	VirtualMachineSizeTypesStandardNc24Sv3  VirtualMachineSizeTypes = "Standard_NC24s_v3"
	VirtualMachineSizeTypesStandardNc6      VirtualMachineSizeTypes = "Standard_NC6"
	VirtualMachineSizeTypesStandardNc6Sv2   VirtualMachineSizeTypes = "Standard_NC6s_v2"
	VirtualMachineSizeTypesStandardNc6Sv3   VirtualMachineSizeTypes = "Standard_NC6s_v3"
	VirtualMachineSizeTypesStandardNd12S    VirtualMachineSizeTypes = "Standard_ND12s"
	VirtualMachineSizeTypesStandardNd24Rs   VirtualMachineSizeTypes = "Standard_ND24rs"
	VirtualMachineSizeTypesStandardNd24S    VirtualMachineSizeTypes = "Standard_ND24s"
	VirtualMachineSizeTypesStandardNd6S     VirtualMachineSizeTypes = "Standard_ND6s"
	VirtualMachineSizeTypesStandardNv12     VirtualMachineSizeTypes = "Standard_NV12"
	VirtualMachineSizeTypesStandardNv24     VirtualMachineSizeTypes = "Standard_NV24"
	VirtualMachineSizeTypesStandardNv6      VirtualMachineSizeTypes = "Standard_NV6"
)

func PossibleVirtualMachineSizeTypesValues() []VirtualMachineSizeTypes {
	return []VirtualMachineSizeTypes{
		VirtualMachineSizeTypesBasicA0,
		VirtualMachineSizeTypesBasicA1,
		VirtualMachineSizeTypesBasicA2,
		VirtualMachineSizeTypesBasicA3,
		VirtualMachineSizeTypesBasicA4,
		VirtualMachineSizeTypesStandardA0,
		VirtualMachineSizeTypesStandardA1,
		VirtualMachineSizeTypesStandardA10,
		VirtualMachineSizeTypesStandardA11,
		VirtualMachineSizeTypesStandardA1V2,
		VirtualMachineSizeTypesStandardA2,
		VirtualMachineSizeTypesStandardA2Mv2,
		VirtualMachineSizeTypesStandardA2V2,
		VirtualMachineSizeTypesStandardA3,
		VirtualMachineSizeTypesStandardA4,
		VirtualMachineSizeTypesStandardA4Mv2,
		VirtualMachineSizeTypesStandardA4V2,
		VirtualMachineSizeTypesStandardA5,
		VirtualMachineSizeTypesStandardA6,
		VirtualMachineSizeTypesStandardA7,
		VirtualMachineSizeTypesStandardA8,
		VirtualMachineSizeTypesStandardA8Mv2,
		VirtualMachineSizeTypesStandardA8V2,
		VirtualMachineSizeTypesStandardA9,
		VirtualMachineSizeTypesStandardB1MS,
		VirtualMachineSizeTypesStandardB1S,
		VirtualMachineSizeTypesStandardB2MS,
		VirtualMachineSizeTypesStandardB2S,
		VirtualMachineSizeTypesStandardB4MS,
		VirtualMachineSizeTypesStandardB8MS,
		VirtualMachineSizeTypesStandardD1,
		VirtualMachineSizeTypesStandardD11,
		VirtualMachineSizeTypesStandardD11V2,
		VirtualMachineSizeTypesStandardD12,
		VirtualMachineSizeTypesStandardD12V2,
		VirtualMachineSizeTypesStandardD13,
		VirtualMachineSizeTypesStandardD13V2,
		VirtualMachineSizeTypesStandardD14,
		VirtualMachineSizeTypesStandardD14V2,
		VirtualMachineSizeTypesStandardD15V2,
		VirtualMachineSizeTypesStandardD16Sv3,
		VirtualMachineSizeTypesStandardD16V3,
		VirtualMachineSizeTypesStandardD1V2,
		VirtualMachineSizeTypesStandardD2,
		VirtualMachineSizeTypesStandardD2Sv3,
		VirtualMachineSizeTypesStandardD2V2,
		VirtualMachineSizeTypesStandardD2V3,
		VirtualMachineSizeTypesStandardD3,
		VirtualMachineSizeTypesStandardD32Sv3,
		VirtualMachineSizeTypesStandardD32V3,
		VirtualMachineSizeTypesStandardD3V2,
		VirtualMachineSizeTypesStandardD4,
		VirtualMachineSizeTypesStandardD4Sv3,
		VirtualMachineSizeTypesStandardD4V2,
		VirtualMachineSizeTypesStandardD4V3,
		VirtualMachineSizeTypesStandardD5V2,
		VirtualMachineSizeTypesStandardD64Sv3,
		VirtualMachineSizeTypesStandardD64V3,
		VirtualMachineSizeTypesStandardD8Sv3,
		VirtualMachineSizeTypesStandardD8V3,
		VirtualMachineSizeTypesStandardDs1,
		VirtualMachineSizeTypesStandardDs11,
		VirtualMachineSizeTypesStandardDs11V2,
		VirtualMachineSizeTypesStandardDs12,
		VirtualMachineSizeTypesStandardDs12V2,
		VirtualMachineSizeTypesStandardDs13,
		VirtualMachineSizeTypesStandardDs132V2,
		VirtualMachineSizeTypesStandardDs134V2,
		VirtualMachineSizeTypesStandardDs13V2,
		VirtualMachineSizeTypesStandardDs14,
		VirtualMachineSizeTypesStandardDs144V2,
		VirtualMachineSizeTypesStandardDs148V2,
		VirtualMachineSizeTypesStandardDs14V2,
		VirtualMachineSizeTypesStandardDs15V2,
		VirtualMachineSizeTypesStandardDs1V2,
		VirtualMachineSizeTypesStandardDs2,
		VirtualMachineSizeTypesStandardDs2V2,
		VirtualMachineSizeTypesStandardDs3,
		VirtualMachineSizeTypesStandardDs3V2,
		VirtualMachineSizeTypesStandardDs4,
		VirtualMachineSizeTypesStandardDs4V2,
		VirtualMachineSizeTypesStandardDs5V2,
		VirtualMachineSizeTypesStandardE16Sv3,
		VirtualMachineSizeTypesStandardE16V3,
		VirtualMachineSizeTypesStandardE2Sv3,
		VirtualMachineSizeTypesStandardE2V3,
		VirtualMachineSizeTypesStandardE3216V3,
		VirtualMachineSizeTypesStandardE328Sv3,
		VirtualMachineSizeTypesStandardE32Sv3,
		VirtualMachineSizeTypesStandardE32V3,
		VirtualMachineSizeTypesStandardE4Sv3,
		VirtualMachineSizeTypesStandardE4V3,
		VirtualMachineSizeTypesStandardE6416Sv3,
		VirtualMachineSizeTypesStandardE6432Sv3,
		VirtualMachineSizeTypesStandardE64Sv3,
		VirtualMachineSizeTypesStandardE64V3,
		VirtualMachineSizeTypesStandardE8Sv3,
		VirtualMachineSizeTypesStandardE8V3,
		VirtualMachineSizeTypesStandardF1,
		VirtualMachineSizeTypesStandardF16,
		VirtualMachineSizeTypesStandardF16S,
		VirtualMachineSizeTypesStandardF16Sv2,
		VirtualMachineSizeTypesStandardF1S,
		VirtualMachineSizeTypesStandardF2,
		VirtualMachineSizeTypesStandardF2S,
		VirtualMachineSizeTypesStandardF2Sv2,
		VirtualMachineSizeTypesStandardF32Sv2,
		VirtualMachineSizeTypesStandardF4,
		VirtualMachineSizeTypesStandardF4S,
		VirtualMachineSizeTypesStandardF4Sv2,
		VirtualMachineSizeTypesStandardF64Sv2,
		VirtualMachineSizeTypesStandardF72Sv2,
		VirtualMachineSizeTypesStandardF8,
		VirtualMachineSizeTypesStandardF8S,
		VirtualMachineSizeTypesStandardF8Sv2,
		VirtualMachineSizeTypesStandardG1,
		VirtualMachineSizeTypesStandardG2,
		VirtualMachineSizeTypesStandardG3,
		VirtualMachineSizeTypesStandardG4,
		VirtualMachineSizeTypesStandardG5,
		VirtualMachineSizeTypesStandardGs1,
		VirtualMachineSizeTypesStandardGs2,
		VirtualMachineSizeTypesStandardGs3,
		VirtualMachineSizeTypesStandardGs4,
		VirtualMachineSizeTypesStandardGs44,
		VirtualMachineSizeTypesStandardGs48,
		VirtualMachineSizeTypesStandardGs5,
		VirtualMachineSizeTypesStandardGs516,
		VirtualMachineSizeTypesStandardGs58,
		VirtualMachineSizeTypesStandardH16,
		VirtualMachineSizeTypesStandardH16M,
		VirtualMachineSizeTypesStandardH16Mr,
		VirtualMachineSizeTypesStandardH16R,
		VirtualMachineSizeTypesStandardH8,
		VirtualMachineSizeTypesStandardH8M,
		VirtualMachineSizeTypesStandardL16S,
		VirtualMachineSizeTypesStandardL32S,
		VirtualMachineSizeTypesStandardL4S,
		VirtualMachineSizeTypesStandardL8S,
		VirtualMachineSizeTypesStandardM12832MS,
		VirtualMachineSizeTypesStandardM12864MS,
		VirtualMachineSizeTypesStandardM128MS,
		VirtualMachineSizeTypesStandardM128S,
		VirtualMachineSizeTypesStandardM6416MS,
		VirtualMachineSizeTypesStandardM6432MS,
		VirtualMachineSizeTypesStandardM64MS,
		VirtualMachineSizeTypesStandardM64S,
		VirtualMachineSizeTypesStandardNc12,
		VirtualMachineSizeTypesStandardNc12Sv2,
		VirtualMachineSizeTypesStandardNc12Sv3,
		VirtualMachineSizeTypesStandardNc24,
		VirtualMachineSizeTypesStandardNc24R,
		VirtualMachineSizeTypesStandardNc24RsV2,
		VirtualMachineSizeTypesStandardNc24RsV3,
		VirtualMachineSizeTypesStandardNc24Sv2,
		VirtualMachineSizeTypesStandardNc24Sv3,
		VirtualMachineSizeTypesStandardNc6,
		VirtualMachineSizeTypesStandardNc6Sv2,
		VirtualMachineSizeTypesStandardNc6Sv3,
		VirtualMachineSizeTypesStandardNd12S,
		VirtualMachineSizeTypesStandardNd24Rs,
		VirtualMachineSizeTypesStandardNd24S,
		VirtualMachineSizeTypesStandardNd6S,
		VirtualMachineSizeTypesStandardNv12,
		VirtualMachineSizeTypesStandardNv24,
		VirtualMachineSizeTypesStandardNv6,
	}
}

func (c VirtualMachineSizeTypes) ToPtr() *VirtualMachineSizeTypes {
	return &c
}