sdk/batch/azbatch/constants.go

// 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) Go Code Generator. DO NOT EDIT.

package azbatch

// AccessScope - AccessScope enums
type AccessScope string

const (
	// AccessScopeJob - Grants access to perform all operations on the Job containing the Task.
	AccessScopeJob AccessScope = "job"
)

// PossibleAccessScopeValues returns the possible values for the AccessScope const type.
func PossibleAccessScopeValues() []AccessScope {
	return []AccessScope{
		AccessScopeJob,
	}
}

// AllocationState - AllocationState enums
type AllocationState string

const (
	// AllocationStateResizing - The Pool is resizing; that is, Compute Nodes are being added to or removed from the Pool.
	AllocationStateResizing AllocationState = "resizing"
	// AllocationStateSteady - The Pool is not resizing. There are no changes to the number of Compute Nodes in the Pool in progress.
	// A Pool enters this state when it is created and when no operations are being performed on the Pool to change the number
	// of Compute Nodes.
	AllocationStateSteady AllocationState = "steady"
	// AllocationStateStopping - The Pool was resizing, but the user has requested that the resize be stopped, but the stop request
	// has not yet been completed.
	AllocationStateStopping AllocationState = "stopping"
)

// PossibleAllocationStateValues returns the possible values for the AllocationState const type.
func PossibleAllocationStateValues() []AllocationState {
	return []AllocationState{
		AllocationStateResizing,
		AllocationStateSteady,
		AllocationStateStopping,
	}
}

// AutoUserScope - AutoUserScope enums
type AutoUserScope string

const (
	// AutoUserScopePool - Specifies that the Task runs as the common auto user Account which is created on every Compute Node
	// in a Pool.
	AutoUserScopePool AutoUserScope = "pool"
	// AutoUserScopeTask - Specifies that the service should create a new user for the Task.
	AutoUserScopeTask AutoUserScope = "task"
)

// PossibleAutoUserScopeValues returns the possible values for the AutoUserScope const type.
func PossibleAutoUserScopeValues() []AutoUserScope {
	return []AutoUserScope{
		AutoUserScopePool,
		AutoUserScopeTask,
	}
}

// CachingType - CachingType enums
type CachingType string

const (
	// CachingTypeNone - The caching mode for the disk is not enabled.
	CachingTypeNone CachingType = "none"
	// CachingTypeReadOnly - The caching mode for the disk is read only.
	CachingTypeReadOnly CachingType = "readonly"
	// CachingTypeReadWrite - The caching mode for the disk is read and write.
	CachingTypeReadWrite CachingType = "readwrite"
)

// PossibleCachingTypeValues returns the possible values for the CachingType const type.
func PossibleCachingTypeValues() []CachingType {
	return []CachingType{
		CachingTypeNone,
		CachingTypeReadOnly,
		CachingTypeReadWrite,
	}
}

// CertificateFormat - BatchCertificateFormat enums
type CertificateFormat string

const (
	// CertificateFormatCER - The Certificate is a base64-encoded X.509 Certificate.
	CertificateFormatCER CertificateFormat = "cer"
	// CertificateFormatPFX - The Certificate is a PFX (PKCS#12) formatted Certificate or Certificate chain.
	CertificateFormatPFX CertificateFormat = "pfx"
)

// PossibleCertificateFormatValues returns the possible values for the CertificateFormat const type.
func PossibleCertificateFormatValues() []CertificateFormat {
	return []CertificateFormat{
		CertificateFormatCER,
		CertificateFormatPFX,
	}
}

// CertificateState - BatchCertificateState enums
type CertificateState string

const (
	// CertificateStateActive - The Certificate is available for use in Pools.
	CertificateStateActive CertificateState = "active"
	// CertificateStateDeleteFailed - The user requested that the Certificate be deleted, but there are Pools that still have
	// references to the Certificate, or it is still installed on one or more Nodes. (The latter can occur if the Certificate
	// has been removed from the Pool, but the Compute Node has not yet restarted. Compute Nodes refresh their Certificates only
	// when they restart.) You may use the cancel Certificate delete operation to cancel the delete, or the delete Certificate
	// operation to retry the delete.
	CertificateStateDeleteFailed CertificateState = "deletefailed"
	// CertificateStateDeleting - The user has requested that the Certificate be deleted, but the delete operation has not yet
	// completed. You may not reference the Certificate when creating or updating Pools.
	CertificateStateDeleting CertificateState = "deleting"
)

// PossibleCertificateStateValues returns the possible values for the CertificateState const type.
func PossibleCertificateStateValues() []CertificateState {
	return []CertificateState{
		CertificateStateActive,
		CertificateStateDeleteFailed,
		CertificateStateDeleting,
	}
}

// CertificateStoreLocation - BatchCertificateStoreLocation enums
type CertificateStoreLocation string

const (
	// CertificateStoreLocationCurrentUser - Certificates should be installed to the CurrentUser Certificate store.
	CertificateStoreLocationCurrentUser CertificateStoreLocation = "currentuser"
	// CertificateStoreLocationLocalMachine - Certificates should be installed to the LocalMachine Certificate store.
	CertificateStoreLocationLocalMachine CertificateStoreLocation = "localmachine"
)

// PossibleCertificateStoreLocationValues returns the possible values for the CertificateStoreLocation const type.
func PossibleCertificateStoreLocationValues() []CertificateStoreLocation {
	return []CertificateStoreLocation{
		CertificateStoreLocationCurrentUser,
		CertificateStoreLocationLocalMachine,
	}
}

// CertificateVisibility - BatchCertificateVisibility enums
type CertificateVisibility string

const (
	// CertificateVisibilityRemoteUser - The Certificate should be visible to the user accounts under which users remotely access
	// the Compute Node.
	CertificateVisibilityRemoteUser CertificateVisibility = "remoteuser"
	// CertificateVisibilityStartTask - The Certificate should be visible to the user account under which the StartTask is run.
	// Note that if AutoUser Scope is Pool for both the StartTask and a Task, this certificate will be visible to the Task as
	// well.
	CertificateVisibilityStartTask CertificateVisibility = "starttask"
	// CertificateVisibilityTask - The Certificate should be visible to the user accounts under which Job Tasks are run.
	CertificateVisibilityTask CertificateVisibility = "task"
)

// PossibleCertificateVisibilityValues returns the possible values for the CertificateVisibility const type.
func PossibleCertificateVisibilityValues() []CertificateVisibility {
	return []CertificateVisibility{
		CertificateVisibilityRemoteUser,
		CertificateVisibilityStartTask,
		CertificateVisibilityTask,
	}
}

// ContainerHostDataPath - The paths which will be mounted to container task's container.
type ContainerHostDataPath string

const (
	// ContainerHostDataPathApplications - The applications path.
	ContainerHostDataPathApplications ContainerHostDataPath = "Applications"
	// ContainerHostDataPathJobPrep - The job-prep task path.
	ContainerHostDataPathJobPrep ContainerHostDataPath = "JobPrep"
	// ContainerHostDataPathShared - The path for multi-instances task to shared their files.
	ContainerHostDataPathShared ContainerHostDataPath = "Shared"
	// ContainerHostDataPathStartup - The path for start task.
	ContainerHostDataPathStartup ContainerHostDataPath = "Startup"
	// ContainerHostDataPathTask - The task path.
	ContainerHostDataPathTask ContainerHostDataPath = "Task"
	// ContainerHostDataPathVfsMounts - The path contains all virtual file systems are mounted on this node.
	ContainerHostDataPathVfsMounts ContainerHostDataPath = "VfsMounts"
)

// PossibleContainerHostDataPathValues returns the possible values for the ContainerHostDataPath const type.
func PossibleContainerHostDataPathValues() []ContainerHostDataPath {
	return []ContainerHostDataPath{
		ContainerHostDataPathApplications,
		ContainerHostDataPathJobPrep,
		ContainerHostDataPathShared,
		ContainerHostDataPathStartup,
		ContainerHostDataPathTask,
		ContainerHostDataPathVfsMounts,
	}
}

// ContainerType - ContainerType enums
type ContainerType string

const (
	// ContainerTypeCriCompatible - A CRI based technology will be used to launch the containers.
	ContainerTypeCriCompatible ContainerType = "criCompatible"
	// ContainerTypeDockerCompatible - A Docker compatible container technology will be used to launch the containers.
	ContainerTypeDockerCompatible ContainerType = "dockerCompatible"
)

// PossibleContainerTypeValues returns the possible values for the ContainerType const type.
func PossibleContainerTypeValues() []ContainerType {
	return []ContainerType{
		ContainerTypeCriCompatible,
		ContainerTypeDockerCompatible,
	}
}

// ContainerWorkingDirectory - ContainerWorkingDirectory enums
type ContainerWorkingDirectory string

const (
	// ContainerWorkingDirectoryContainerImageDefault - Use the working directory defined in the container Image. Beware that
	// this directory will not contain the Resource Files downloaded by Batch.
	ContainerWorkingDirectoryContainerImageDefault ContainerWorkingDirectory = "containerImageDefault"
	// ContainerWorkingDirectoryTaskWorkingDirectory - Use the standard Batch service Task working directory, which will contain
	// the Task Resource Files populated by Batch.
	ContainerWorkingDirectoryTaskWorkingDirectory ContainerWorkingDirectory = "taskWorkingDirectory"
)

// PossibleContainerWorkingDirectoryValues returns the possible values for the ContainerWorkingDirectory const type.
func PossibleContainerWorkingDirectoryValues() []ContainerWorkingDirectory {
	return []ContainerWorkingDirectory{
		ContainerWorkingDirectoryContainerImageDefault,
		ContainerWorkingDirectoryTaskWorkingDirectory,
	}
}

// DependencyAction - DependencyAction enums
type DependencyAction string

const (
	// DependencyActionBlock - Blocks tasks waiting on this task, preventing them from being scheduled.
	DependencyActionBlock DependencyAction = "block"
	// DependencyActionSatisfy - Satisfy tasks waiting on this task; once all dependencies are satisfied, the task will be scheduled
	// to run.
	DependencyActionSatisfy DependencyAction = "satisfy"
)

// PossibleDependencyActionValues returns the possible values for the DependencyAction const type.
func PossibleDependencyActionValues() []DependencyAction {
	return []DependencyAction{
		DependencyActionBlock,
		DependencyActionSatisfy,
	}
}

// DiffDiskPlacement - Specifies the ephemeral disk placement for operating system disk for all compute nodes (VMs) in the
// pool. This property can be used by user in the request to choose which location the operating system should be in. e.g.,
// cache disk space for Ephemeral OS disk provisioning. For more information on Ephemeral OS disk size requirements, please
// refer to Ephemeral OS disk size requirements for Windows VMs at https://learn.microsoft.com/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements
// and Linux VMs at https://learn.microsoft.com/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements
type DiffDiskPlacement string

const (
	// DiffDiskPlacementCacheDisk - The Ephemeral OS Disk is stored on the VM cache.
	DiffDiskPlacementCacheDisk DiffDiskPlacement = "cachedisk"
)

// PossibleDiffDiskPlacementValues returns the possible values for the DiffDiskPlacement const type.
func PossibleDiffDiskPlacementValues() []DiffDiskPlacement {
	return []DiffDiskPlacement{
		DiffDiskPlacementCacheDisk,
	}
}

// DisableJobOption - DisableBatchJobOption enums
type DisableJobOption string

const (
	// DisableJobOptionRequeue - Terminate running Tasks and requeue them. The Tasks will run again when the Job is enabled.
	DisableJobOptionRequeue DisableJobOption = "requeue"
	// DisableJobOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating that they
	// were terminated, and will not run again.
	DisableJobOptionTerminate DisableJobOption = "terminate"
	// DisableJobOptionWait - Allow currently running Tasks to complete.
	DisableJobOptionWait DisableJobOption = "wait"
)

// PossibleDisableJobOptionValues returns the possible values for the DisableJobOption const type.
func PossibleDisableJobOptionValues() []DisableJobOption {
	return []DisableJobOption{
		DisableJobOptionRequeue,
		DisableJobOptionTerminate,
		DisableJobOptionWait,
	}
}

// DiskEncryptionTarget - DiskEncryptionTarget enums
type DiskEncryptionTarget string

const (
	// DiskEncryptionTargetOsDisk - The OS Disk on the compute node is encrypted.
	DiskEncryptionTargetOsDisk DiskEncryptionTarget = "osdisk"
	// DiskEncryptionTargetTemporaryDisk - The temporary disk on the compute node is encrypted. On Linux this encryption applies
	// to other partitions (such as those on mounted data disks) when encryption occurs at boot time.
	DiskEncryptionTargetTemporaryDisk DiskEncryptionTarget = "temporarydisk"
)

// PossibleDiskEncryptionTargetValues returns the possible values for the DiskEncryptionTarget const type.
func PossibleDiskEncryptionTargetValues() []DiskEncryptionTarget {
	return []DiskEncryptionTarget{
		DiskEncryptionTargetOsDisk,
		DiskEncryptionTargetTemporaryDisk,
	}
}

// DynamicVNetAssignmentScope - DynamicVNetAssignmentScope enums
type DynamicVNetAssignmentScope string

const (
	// DynamicVNetAssignmentScopeJob - Dynamic VNet assignment is done per-job.
	DynamicVNetAssignmentScopeJob DynamicVNetAssignmentScope = "job"
	// DynamicVNetAssignmentScopeNone - No dynamic VNet assignment is enabled.
	DynamicVNetAssignmentScopeNone DynamicVNetAssignmentScope = "none"
)

// PossibleDynamicVNetAssignmentScopeValues returns the possible values for the DynamicVNetAssignmentScope const type.
func PossibleDynamicVNetAssignmentScopeValues() []DynamicVNetAssignmentScope {
	return []DynamicVNetAssignmentScope{
		DynamicVNetAssignmentScopeJob,
		DynamicVNetAssignmentScopeNone,
	}
}

// ElevationLevel - ElevationLevel enums
type ElevationLevel string

const (
	// ElevationLevelAdmin - The user is a user with elevated access and operates with full Administrator permissions.
	ElevationLevelAdmin ElevationLevel = "admin"
	// ElevationLevelNonAdmin - The user is a standard user without elevated access.
	ElevationLevelNonAdmin ElevationLevel = "nonadmin"
)

// PossibleElevationLevelValues returns the possible values for the ElevationLevel const type.
func PossibleElevationLevelValues() []ElevationLevel {
	return []ElevationLevel{
		ElevationLevelAdmin,
		ElevationLevelNonAdmin,
	}
}

// ErrorCategory - ErrorCategory enums
type ErrorCategory string

const (
	// ErrorCategoryServerError - The error is due to an internal server issue.
	ErrorCategoryServerError ErrorCategory = "servererror"
	// ErrorCategoryUserError - The error is due to a user issue, such as misconfiguration.
	ErrorCategoryUserError ErrorCategory = "usererror"
)

// PossibleErrorCategoryValues returns the possible values for the ErrorCategory const type.
func PossibleErrorCategoryValues() []ErrorCategory {
	return []ErrorCategory{
		ErrorCategoryServerError,
		ErrorCategoryUserError,
	}
}

// IPAddressProvisioningType - IPAddressProvisioningType enums
type IPAddressProvisioningType string

const (
	// IPAddressProvisioningTypeBatchManaged - A public IP will be created and managed by Batch. There may be multiple public
	// IPs depending on the size of the Pool.
	IPAddressProvisioningTypeBatchManaged IPAddressProvisioningType = "batchmanaged"
	// IPAddressProvisioningTypeNoPublicIPAddresses - No public IP Address will be created.
	IPAddressProvisioningTypeNoPublicIPAddresses IPAddressProvisioningType = "nopublicipaddresses"
	// IPAddressProvisioningTypeUserManaged - Public IPs are provided by the user and will be used to provision the Compute Nodes.
	IPAddressProvisioningTypeUserManaged IPAddressProvisioningType = "usermanaged"
)

// PossibleIPAddressProvisioningTypeValues returns the possible values for the IPAddressProvisioningType const type.
func PossibleIPAddressProvisioningTypeValues() []IPAddressProvisioningType {
	return []IPAddressProvisioningType{
		IPAddressProvisioningTypeBatchManaged,
		IPAddressProvisioningTypeNoPublicIPAddresses,
		IPAddressProvisioningTypeUserManaged,
	}
}

// ImageVerificationType - ImageVerificationType enums
type ImageVerificationType string

const (
	// ImageVerificationTypeUnverified - The associated Compute Node agent SKU should have binary compatibility with the Image,
	// but specific functionality has not been verified.
	ImageVerificationTypeUnverified ImageVerificationType = "unverified"
	// ImageVerificationTypeVerified - The Image is guaranteed to be compatible with the associated Compute Node agent SKU and
	// all Batch features have been confirmed to work as expected.
	ImageVerificationTypeVerified ImageVerificationType = "verified"
)

// PossibleImageVerificationTypeValues returns the possible values for the ImageVerificationType const type.
func PossibleImageVerificationTypeValues() []ImageVerificationType {
	return []ImageVerificationType{
		ImageVerificationTypeUnverified,
		ImageVerificationTypeVerified,
	}
}

// InboundEndpointProtocol - InboundEndpointProtocol enums
type InboundEndpointProtocol string

const (
	// InboundEndpointProtocolTCP - Use TCP for the endpoint.
	InboundEndpointProtocolTCP InboundEndpointProtocol = "tcp"
	// InboundEndpointProtocolUDP - Use UDP for the endpoint.
	InboundEndpointProtocolUDP InboundEndpointProtocol = "udp"
)

// PossibleInboundEndpointProtocolValues returns the possible values for the InboundEndpointProtocol const type.
func PossibleInboundEndpointProtocolValues() []InboundEndpointProtocol {
	return []InboundEndpointProtocol{
		InboundEndpointProtocolTCP,
		InboundEndpointProtocolUDP,
	}
}

// JobAction - BatchJobAction enums
type JobAction string

const (
	// JobActionDisable - Disable the Job. This is equivalent to calling the disable Job API, with a disableTasks value of requeue.
	JobActionDisable JobAction = "disable"
	// JobActionNone - Take no action.
	JobActionNone JobAction = "none"
	// JobActionTerminate - Terminate the Job. The terminationReason in the Job's executionInfo is set to "TaskFailed".
	JobActionTerminate JobAction = "terminate"
)

// PossibleJobActionValues returns the possible values for the JobAction const type.
func PossibleJobActionValues() []JobAction {
	return []JobAction{
		JobActionDisable,
		JobActionNone,
		JobActionTerminate,
	}
}

// JobPreparationTaskState - BatchJobPreparationTaskState enums
type JobPreparationTaskState string

const (
	// JobPreparationTaskStateCompleted - The Task has exited with exit code 0, or the Task has exhausted its retry limit, or
	// the Batch service was unable to start the Task due to Task preparation errors (such as resource file download failures).
	JobPreparationTaskStateCompleted JobPreparationTaskState = "completed"
	// JobPreparationTaskStateRunning - The Task is currently running (including retrying).
	JobPreparationTaskStateRunning JobPreparationTaskState = "running"
)

// PossibleJobPreparationTaskStateValues returns the possible values for the JobPreparationTaskState const type.
func PossibleJobPreparationTaskStateValues() []JobPreparationTaskState {
	return []JobPreparationTaskState{
		JobPreparationTaskStateCompleted,
		JobPreparationTaskStateRunning,
	}
}

// JobReleaseTaskState - BatchJobReleaseTaskState enums
type JobReleaseTaskState string

const (
	// JobReleaseTaskStateCompleted - The Task has exited with exit code 0, or the Task has exhausted its retry limit, or the
	// Batch service was unable to start the Task due to Task preparation errors (such as resource file download failures).
	JobReleaseTaskStateCompleted JobReleaseTaskState = "completed"
	// JobReleaseTaskStateRunning - The Task is currently running (including retrying).
	JobReleaseTaskStateRunning JobReleaseTaskState = "running"
)

// PossibleJobReleaseTaskStateValues returns the possible values for the JobReleaseTaskState const type.
func PossibleJobReleaseTaskStateValues() []JobReleaseTaskState {
	return []JobReleaseTaskState{
		JobReleaseTaskStateCompleted,
		JobReleaseTaskStateRunning,
	}
}

// JobScheduleState - BatchJobScheduleState enums
type JobScheduleState string

const (
	// JobScheduleStateActive - The Job Schedule is active and will create Jobs as per its schedule.
	JobScheduleStateActive JobScheduleState = "active"
	// JobScheduleStateCompleted - The Job Schedule has terminated, either by reaching its end time or by the user terminating
	// it explicitly.
	JobScheduleStateCompleted JobScheduleState = "completed"
	// JobScheduleStateDeleting - The user has requested that the Job Schedule be deleted, but the delete operation is still in
	// progress. The scheduler will not initiate any new Jobs for this Job Schedule, and will delete any existing Jobs and Tasks
	// under the Job Schedule, including any active Job. The Job Schedule will be deleted when all Jobs and Tasks under the Job
	// Schedule have been deleted.
	JobScheduleStateDeleting JobScheduleState = "deleting"
	// JobScheduleStateDisabled - The user has disabled the Job Schedule. The scheduler will not initiate any new Jobs will on
	// this schedule, but any existing active Job will continue to run.
	JobScheduleStateDisabled JobScheduleState = "disabled"
	// JobScheduleStateTerminating - The Job Schedule has no more work to do, or has been explicitly terminated by the user, but
	// the termination operation is still in progress. The scheduler will not initiate any new Jobs for this Job Schedule, nor
	// is any existing Job active.
	JobScheduleStateTerminating JobScheduleState = "terminating"
)

// PossibleJobScheduleStateValues returns the possible values for the JobScheduleState const type.
func PossibleJobScheduleStateValues() []JobScheduleState {
	return []JobScheduleState{
		JobScheduleStateActive,
		JobScheduleStateCompleted,
		JobScheduleStateDeleting,
		JobScheduleStateDisabled,
		JobScheduleStateTerminating,
	}
}

// JobState - BatchJobState enums
type JobState string

const (
	// JobStateActive - The Job is available to have Tasks scheduled.
	JobStateActive JobState = "active"
	// JobStateCompleted - All Tasks have terminated, and the system will not accept any more Tasks or any further changes to
	// the Job.
	JobStateCompleted JobState = "completed"
	// JobStateDeleting - A user has requested that the Job be deleted, but the delete operation is still in progress (for example,
	// because the system is still terminating running Tasks).
	JobStateDeleting JobState = "deleting"
	// JobStateDisabled - A user has disabled the Job. No Tasks are running, and no new Tasks will be scheduled.
	JobStateDisabled JobState = "disabled"
	// JobStateDisabling - A user has requested that the Job be disabled, but the disable operation is still in progress (for
	// example, waiting for Tasks to terminate).
	JobStateDisabling JobState = "disabling"
	// JobStateEnabling - A user has requested that the Job be enabled, but the enable operation is still in progress.
	JobStateEnabling JobState = "enabling"
	// JobStateTerminating - The Job is about to complete, either because a Job Manager Task has completed or because the user
	// has terminated the Job, but the terminate operation is still in progress (for example, because Job Release Tasks are running).
	JobStateTerminating JobState = "terminating"
)

// PossibleJobStateValues returns the possible values for the JobState const type.
func PossibleJobStateValues() []JobState {
	return []JobState{
		JobStateActive,
		JobStateCompleted,
		JobStateDeleting,
		JobStateDisabled,
		JobStateDisabling,
		JobStateEnabling,
		JobStateTerminating,
	}
}

// LoginMode - LoginMode enums
type LoginMode string

const (
	// LoginModeBatch - The LOGON32_LOGON_BATCH Win32 login mode. The batch login mode is recommended for long running parallel
	// processes.
	LoginModeBatch LoginMode = "batch"
	// LoginModeInteractive - The LOGON32_LOGON_INTERACTIVE Win32 login mode. UAC is enabled on Windows VirtualMachineConfiguration
	// Pools. If this option is used with an elevated user identity in a Windows VirtualMachineConfiguration Pool, the user session
	// will not be elevated unless the application executed by the Task command line is configured to always require administrative
	// privilege or to always require maximum privilege.
	LoginModeInteractive LoginMode = "interactive"
)

// PossibleLoginModeValues returns the possible values for the LoginMode const type.
func PossibleLoginModeValues() []LoginMode {
	return []LoginMode{
		LoginModeBatch,
		LoginModeInteractive,
	}
}

// NetworkSecurityGroupRuleAccess - NetworkSecurityGroupRuleAccess enums
type NetworkSecurityGroupRuleAccess string

const (
	// NetworkSecurityGroupRuleAccessAllow - Allow access.
	NetworkSecurityGroupRuleAccessAllow NetworkSecurityGroupRuleAccess = "allow"
	// NetworkSecurityGroupRuleAccessDeny - Deny access.
	NetworkSecurityGroupRuleAccessDeny NetworkSecurityGroupRuleAccess = "deny"
)

// PossibleNetworkSecurityGroupRuleAccessValues returns the possible values for the NetworkSecurityGroupRuleAccess const type.
func PossibleNetworkSecurityGroupRuleAccessValues() []NetworkSecurityGroupRuleAccess {
	return []NetworkSecurityGroupRuleAccess{
		NetworkSecurityGroupRuleAccessAllow,
		NetworkSecurityGroupRuleAccessDeny,
	}
}

// NodeCommunicationMode - BatchNodeCommunicationMode enums
type NodeCommunicationMode string

const (
	// NodeCommunicationModeClassic - Nodes using the classic communication mode require inbound TCP communication on ports 29876
	// and 29877 from the "BatchNodeManagement.{region}" service tag and outbound TCP communication on port 443 to the "Storage.region"
	// and "BatchNodeManagement.{region}" service tags.
	NodeCommunicationModeClassic NodeCommunicationMode = "classic"
	// NodeCommunicationModeDefault - The node communication mode is automatically set by the Batch service.
	NodeCommunicationModeDefault NodeCommunicationMode = "default"
	// NodeCommunicationModeSimplified - Nodes using the simplified communication mode require outbound TCP communication on port
	// 443 to the "BatchNodeManagement.{region}" service tag. No open inbound ports are required.
	NodeCommunicationModeSimplified NodeCommunicationMode = "simplified"
)

// PossibleNodeCommunicationModeValues returns the possible values for the NodeCommunicationMode const type.
func PossibleNodeCommunicationModeValues() []NodeCommunicationMode {
	return []NodeCommunicationMode{
		NodeCommunicationModeClassic,
		NodeCommunicationModeDefault,
		NodeCommunicationModeSimplified,
	}
}

// NodeDeallocateOption - BatchNodeDeallocateOption enums
type NodeDeallocateOption string

const (
	// NodeDeallocateOptionRequeue - Terminate running Task processes and requeue the Tasks. The Tasks will run again when a Compute
	// Node is available. Deallocate the Compute Node as soon as Tasks have been terminated.
	NodeDeallocateOptionRequeue NodeDeallocateOption = "requeue"
	// NodeDeallocateOptionRetainedData - Allow currently running Tasks to complete, then wait for all Task data retention periods
	// to expire. Schedule no new Tasks while waiting. Deallocate the Compute Node when all Task retention periods have expired.
	NodeDeallocateOptionRetainedData NodeDeallocateOption = "retaineddata"
	// NodeDeallocateOptionTaskCompletion - Allow currently running Tasks to complete. Schedule no new Tasks while waiting. Deallocate
	// the Compute Node when all Tasks have completed.
	NodeDeallocateOptionTaskCompletion NodeDeallocateOption = "taskcompletion"
	// NodeDeallocateOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating that they
	// were terminated, and will not run again. Deallocate the Compute Node as soon as Tasks have been terminated.
	NodeDeallocateOptionTerminate NodeDeallocateOption = "terminate"
)

// PossibleNodeDeallocateOptionValues returns the possible values for the NodeDeallocateOption const type.
func PossibleNodeDeallocateOptionValues() []NodeDeallocateOption {
	return []NodeDeallocateOption{
		NodeDeallocateOptionRequeue,
		NodeDeallocateOptionRetainedData,
		NodeDeallocateOptionTaskCompletion,
		NodeDeallocateOptionTerminate,
	}
}

// NodeDeallocationOption - BatchNodeDeallocationOption enums
type NodeDeallocationOption string

const (
	// NodeDeallocationOptionRequeue - Terminate running Task processes and requeue the Tasks. The Tasks will run again when a
	// Compute Node is available. Remove Compute Nodes as soon as Tasks have been terminated.
	NodeDeallocationOptionRequeue NodeDeallocationOption = "requeue"
	// NodeDeallocationOptionRetainedData - Allow currently running Tasks to complete, then wait for all Task data retention periods
	// to expire. Schedule no new Tasks while waiting. Remove Compute Nodes when all Task retention periods have expired.
	NodeDeallocationOptionRetainedData NodeDeallocationOption = "retaineddata"
	// NodeDeallocationOptionTaskCompletion - Allow currently running Tasks to complete. Schedule no new Tasks while waiting.
	// Remove Compute Nodes when all Tasks have completed.
	NodeDeallocationOptionTaskCompletion NodeDeallocationOption = "taskcompletion"
	// NodeDeallocationOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating that
	// they were terminated, and will not run again. Remove Compute Nodes as soon as Tasks have been terminated.
	NodeDeallocationOptionTerminate NodeDeallocationOption = "terminate"
)

// PossibleNodeDeallocationOptionValues returns the possible values for the NodeDeallocationOption const type.
func PossibleNodeDeallocationOptionValues() []NodeDeallocationOption {
	return []NodeDeallocationOption{
		NodeDeallocationOptionRequeue,
		NodeDeallocationOptionRetainedData,
		NodeDeallocationOptionTaskCompletion,
		NodeDeallocationOptionTerminate,
	}
}

// NodeDisableSchedulingOption - BatchNodeDisableSchedulingOption enums
type NodeDisableSchedulingOption string

const (
	// NodeDisableSchedulingOptionRequeue - Terminate running Task processes and requeue the Tasks. The Tasks may run again on
	// other Compute Nodes, or when Task scheduling is re-enabled on this Compute Node. Enter offline state as soon as Tasks have
	// been terminated.
	NodeDisableSchedulingOptionRequeue NodeDisableSchedulingOption = "requeue"
	// NodeDisableSchedulingOptionTaskCompletion - Allow currently running Tasks to complete. Schedule no new Tasks while waiting.
	// Enter offline state when all Tasks have completed.
	NodeDisableSchedulingOptionTaskCompletion NodeDisableSchedulingOption = "taskcompletion"
	// NodeDisableSchedulingOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating
	// that they were terminated, and will not run again. Enter offline state as soon as Tasks have been terminated.
	NodeDisableSchedulingOptionTerminate NodeDisableSchedulingOption = "terminate"
)

// PossibleNodeDisableSchedulingOptionValues returns the possible values for the NodeDisableSchedulingOption const type.
func PossibleNodeDisableSchedulingOptionValues() []NodeDisableSchedulingOption {
	return []NodeDisableSchedulingOption{
		NodeDisableSchedulingOptionRequeue,
		NodeDisableSchedulingOptionTaskCompletion,
		NodeDisableSchedulingOptionTerminate,
	}
}

// NodeFillType - BatchNodeFillType enums
type NodeFillType string

const (
	// NodeFillTypePack - As many Tasks as possible (taskSlotsPerNode) should be assigned to each Compute Node in the Pool before
	// any Tasks are assigned to the next Compute Node in the Pool.
	NodeFillTypePack NodeFillType = "pack"
	// NodeFillTypeSpread - Tasks should be assigned evenly across all Compute Nodes in the Pool.
	NodeFillTypeSpread NodeFillType = "spread"
)

// PossibleNodeFillTypeValues returns the possible values for the NodeFillType const type.
func PossibleNodeFillTypeValues() []NodeFillType {
	return []NodeFillType{
		NodeFillTypePack,
		NodeFillTypeSpread,
	}
}

// NodePlacementPolicyType - BatchNodePlacementPolicyType enums
type NodePlacementPolicyType string

const (
	// NodePlacementPolicyTypeRegional - All nodes in the pool will be allocated in the same region.
	NodePlacementPolicyTypeRegional NodePlacementPolicyType = "regional"
	// NodePlacementPolicyTypeZonal - Nodes in the pool will be spread across different availability zones with best effort balancing.
	NodePlacementPolicyTypeZonal NodePlacementPolicyType = "zonal"
)

// PossibleNodePlacementPolicyTypeValues returns the possible values for the NodePlacementPolicyType const type.
func PossibleNodePlacementPolicyTypeValues() []NodePlacementPolicyType {
	return []NodePlacementPolicyType{
		NodePlacementPolicyTypeRegional,
		NodePlacementPolicyTypeZonal,
	}
}

// NodeRebootOption - BatchNodeRebootOption enums
type NodeRebootOption string

const (
	// NodeRebootOptionRequeue - Terminate running Task processes and requeue the Tasks. The Tasks will run again when a Compute
	// Node is available. Restart the Compute Node as soon as Tasks have been terminated.
	NodeRebootOptionRequeue NodeRebootOption = "requeue"
	// NodeRebootOptionRetainedData - Allow currently running Tasks to complete, then wait for all Task data retention periods
	// to expire. Schedule no new Tasks while waiting. Restart the Compute Node when all Task retention periods have expired.
	NodeRebootOptionRetainedData NodeRebootOption = "retaineddata"
	// NodeRebootOptionTaskCompletion - Allow currently running Tasks to complete. Schedule no new Tasks while waiting. Restart
	// the Compute Node when all Tasks have completed.
	NodeRebootOptionTaskCompletion NodeRebootOption = "taskcompletion"
	// NodeRebootOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating that they
	// were terminated, and will not run again. Restart the Compute Node as soon as Tasks have been terminated.
	NodeRebootOptionTerminate NodeRebootOption = "terminate"
)

// PossibleNodeRebootOptionValues returns the possible values for the NodeRebootOption const type.
func PossibleNodeRebootOptionValues() []NodeRebootOption {
	return []NodeRebootOption{
		NodeRebootOptionRequeue,
		NodeRebootOptionRetainedData,
		NodeRebootOptionTaskCompletion,
		NodeRebootOptionTerminate,
	}
}

// NodeReimageOption - BatchNodeReimageOption enums
type NodeReimageOption string

const (
	// NodeReimageOptionRequeue - Terminate running Task processes and requeue the Tasks. The Tasks will run again when a Compute
	// Node is available. Reimage the Compute Node as soon as Tasks have been terminated.
	NodeReimageOptionRequeue NodeReimageOption = "requeue"
	// NodeReimageOptionRetainedData - Allow currently running Tasks to complete, then wait for all Task data retention periods
	// to expire. Schedule no new Tasks while waiting. Reimage the Compute Node when all Task retention periods have expired.
	NodeReimageOptionRetainedData NodeReimageOption = "retaineddata"
	// NodeReimageOptionTaskCompletion - Allow currently running Tasks to complete. Schedule no new Tasks while waiting. Reimage
	// the Compute Node when all Tasks have completed.
	NodeReimageOptionTaskCompletion NodeReimageOption = "taskcompletion"
	// NodeReimageOptionTerminate - Terminate running Tasks. The Tasks will be completed with failureInfo indicating that they
	// were terminated, and will not run again. Reimage the Compute Node as soon as Tasks have been terminated.
	NodeReimageOptionTerminate NodeReimageOption = "terminate"
)

// PossibleNodeReimageOptionValues returns the possible values for the NodeReimageOption const type.
func PossibleNodeReimageOptionValues() []NodeReimageOption {
	return []NodeReimageOption{
		NodeReimageOptionRequeue,
		NodeReimageOptionRetainedData,
		NodeReimageOptionTaskCompletion,
		NodeReimageOptionTerminate,
	}
}

// NodeState - BatchNodeState enums
type NodeState string

const (
	// NodeStateCreating - The Batch service has obtained the underlying virtual machine from Azure Compute, but it has not yet
	// started to join the Pool.
	NodeStateCreating NodeState = "creating"
	// NodeStateDeallocated - The Compute Node is deallocated.
	NodeStateDeallocated NodeState = "deallocated"
	// NodeStateDeallocating - The Compute Node is deallocating.
	NodeStateDeallocating NodeState = "deallocating"
	// NodeStateIdle - The Compute Node is not currently running a Task.
	NodeStateIdle NodeState = "idle"
	// NodeStateLeavingPool - The Compute Node is leaving the Pool, either because the user explicitly removed it or because the
	// Pool is resizing or autoscaling down.
	NodeStateLeavingPool NodeState = "leavingpool"
	// NodeStateOffline - The Compute Node is not currently running a Task, and scheduling of new Tasks to the Compute Node is
	// disabled.
	NodeStateOffline NodeState = "offline"
	// NodeStatePreempted - The Spot/Low-priority Compute Node has been preempted. Tasks which were running on the Compute Node
	// when it was preempted will be rescheduled when another Compute Node becomes available.
	NodeStatePreempted NodeState = "preempted"
	// NodeStateRebooting - The Compute Node is rebooting.
	NodeStateRebooting NodeState = "rebooting"
	// NodeStateReimaging - The Compute Node is reimaging.
	NodeStateReimaging NodeState = "reimaging"
	// NodeStateRunning - The Compute Node is running one or more Tasks (other than a StartTask).
	NodeStateRunning NodeState = "running"
	// NodeStateStartTaskFailed - The StartTask has failed on the Compute Node (and exhausted all retries), and waitForSuccess
	// is set. The Compute Node is not usable for running Tasks.
	NodeStateStartTaskFailed NodeState = "starttaskfailed"
	// NodeStateStarting - The Batch service is starting on the underlying virtual machine.
	NodeStateStarting NodeState = "starting"
	// NodeStateUnknown - The Batch service has lost contact with the Compute Node, and does not know its true state.
	NodeStateUnknown NodeState = "unknown"
	// NodeStateUnusable - The Compute Node cannot be used for Task execution due to errors.
	NodeStateUnusable NodeState = "unusable"
	// NodeStateUpgradingOS - The Compute Node is undergoing an OS upgrade operation.
	NodeStateUpgradingOS NodeState = "upgradingos"
	// NodeStateWaitingForStartTask - The StartTask has started running on the Compute Node, but waitForSuccess is set and the
	// StartTask has not yet completed.
	NodeStateWaitingForStartTask NodeState = "waitingforstarttask"
)

// PossibleNodeStateValues returns the possible values for the NodeState const type.
func PossibleNodeStateValues() []NodeState {
	return []NodeState{
		NodeStateCreating,
		NodeStateDeallocated,
		NodeStateDeallocating,
		NodeStateIdle,
		NodeStateLeavingPool,
		NodeStateOffline,
		NodeStatePreempted,
		NodeStateRebooting,
		NodeStateReimaging,
		NodeStateRunning,
		NodeStateStartTaskFailed,
		NodeStateStarting,
		NodeStateUnknown,
		NodeStateUnusable,
		NodeStateUpgradingOS,
		NodeStateWaitingForStartTask,
	}
}

// OSType - OSType enums
type OSType string

const (
	// OSTypeLinux - The Linux operating system.
	OSTypeLinux OSType = "linux"
	// OSTypeWindows - The Windows operating system.
	OSTypeWindows OSType = "windows"
)

// PossibleOSTypeValues returns the possible values for the OSType const type.
func PossibleOSTypeValues() []OSType {
	return []OSType{
		OSTypeLinux,
		OSTypeWindows,
	}
}

// OnAllTasksComplete - The action the Batch service should take when all Tasks in the Job are in the completed state.
type OnAllTasksComplete string

const (
	// OnAllTasksCompleteNoAction - Do nothing. The Job remains active unless terminated or disabled by some other means.
	OnAllTasksCompleteNoAction OnAllTasksComplete = "noaction"
	// OnAllTasksCompleteTerminateJob - Terminate the Job. The Job's terminationReason is set to 'AllTasksComplete'.
	OnAllTasksCompleteTerminateJob OnAllTasksComplete = "terminatejob"
)

// PossibleOnAllTasksCompleteValues returns the possible values for the OnAllTasksComplete const type.
func PossibleOnAllTasksCompleteValues() []OnAllTasksComplete {
	return []OnAllTasksComplete{
		OnAllTasksCompleteNoAction,
		OnAllTasksCompleteTerminateJob,
	}
}

// OnTaskFailure - OnTaskFailure enums
type OnTaskFailure string

const (
	// OnTaskFailureNoAction - Do nothing. The Job remains active unless terminated or disabled by some other means.
	OnTaskFailureNoAction OnTaskFailure = "noaction"
	// OnTaskFailurePerformExitOptionsJobAction - Terminate the Job. The Job's terminationReason is set to 'AllTasksComplete'.
	OnTaskFailurePerformExitOptionsJobAction OnTaskFailure = "performexitoptionsjobaction"
)

// PossibleOnTaskFailureValues returns the possible values for the OnTaskFailure const type.
func PossibleOnTaskFailureValues() []OnTaskFailure {
	return []OnTaskFailure{
		OnTaskFailureNoAction,
		OnTaskFailurePerformExitOptionsJobAction,
	}
}

// OutputFileUploadCondition - OutputFileUploadCondition enums
type OutputFileUploadCondition string

const (
	// OutputFileUploadConditionTaskCompletion - Upload the file(s) after the Task process exits, no matter what the exit code
	// was.
	OutputFileUploadConditionTaskCompletion OutputFileUploadCondition = "taskcompletion"
	// OutputFileUploadConditionTaskFailure - Upload the file(s) only after the Task process exits with a nonzero exit code.
	OutputFileUploadConditionTaskFailure OutputFileUploadCondition = "taskfailure"
	// OutputFileUploadConditionTaskSuccess - Upload the file(s) only after the Task process exits with an exit code of 0.
	OutputFileUploadConditionTaskSuccess OutputFileUploadCondition = "tasksuccess"
)

// PossibleOutputFileUploadConditionValues returns the possible values for the OutputFileUploadCondition const type.
func PossibleOutputFileUploadConditionValues() []OutputFileUploadCondition {
	return []OutputFileUploadCondition{
		OutputFileUploadConditionTaskCompletion,
		OutputFileUploadConditionTaskFailure,
		OutputFileUploadConditionTaskSuccess,
	}
}

// PoolIdentityType - BatchPoolIdentityType enums
type PoolIdentityType string

const (
	// PoolIdentityTypeNone - Batch pool has no identity associated with it. Setting `None` in update pool will remove existing
	// identities.
	PoolIdentityTypeNone PoolIdentityType = "None"
	// PoolIdentityTypeUserAssigned - Batch pool has user assigned identities with it.
	PoolIdentityTypeUserAssigned PoolIdentityType = "UserAssigned"
)

// PossiblePoolIdentityTypeValues returns the possible values for the PoolIdentityType const type.
func PossiblePoolIdentityTypeValues() []PoolIdentityType {
	return []PoolIdentityType{
		PoolIdentityTypeNone,
		PoolIdentityTypeUserAssigned,
	}
}

// PoolLifetimeOption - BatchPoolLifetimeOption enums
type PoolLifetimeOption string

const (
	// PoolLifetimeOptionJob - The Pool exists for the lifetime of the Job to which it is dedicated. The Batch service creates
	// the Pool when it creates the Job. If the 'job' option is applied to a Job Schedule, the Batch service creates a new auto
	// Pool for every Job created on the schedule.
	PoolLifetimeOptionJob PoolLifetimeOption = "job"
	// PoolLifetimeOptionJobSchedule - The Pool exists for the lifetime of the Job Schedule. The Batch Service creates the Pool
	// when it creates the first Job on the schedule. You may apply this option only to Job Schedules, not to Jobs.
	PoolLifetimeOptionJobSchedule PoolLifetimeOption = "jobschedule"
)

// PossiblePoolLifetimeOptionValues returns the possible values for the PoolLifetimeOption const type.
func PossiblePoolLifetimeOptionValues() []PoolLifetimeOption {
	return []PoolLifetimeOption{
		PoolLifetimeOptionJob,
		PoolLifetimeOptionJobSchedule,
	}
}

// PoolState - BatchPoolState enums
type PoolState string

const (
	// PoolStateActive - The Pool is available to run Tasks subject to the availability of Compute Nodes.
	PoolStateActive PoolState = "active"
	// PoolStateDeleting - The user has requested that the Pool be deleted, but the delete operation has not yet completed.
	PoolStateDeleting PoolState = "deleting"
)

// PossiblePoolStateValues returns the possible values for the PoolState const type.
func PossiblePoolStateValues() []PoolState {
	return []PoolState{
		PoolStateActive,
		PoolStateDeleting,
	}
}

// SchedulingState - SchedulingState enums
type SchedulingState string

const (
	// SchedulingStateDisabled - No new Tasks will be scheduled on the Compute Node. Tasks already running on the Compute Node
	// may still run to completion. All Compute Nodes start with scheduling enabled.
	SchedulingStateDisabled SchedulingState = "disabled"
	// SchedulingStateEnabled - Tasks can be scheduled on the Compute Node.
	SchedulingStateEnabled SchedulingState = "enabled"
)

// PossibleSchedulingStateValues returns the possible values for the SchedulingState const type.
func PossibleSchedulingStateValues() []SchedulingState {
	return []SchedulingState{
		SchedulingStateDisabled,
		SchedulingStateEnabled,
	}
}

// SecurityEncryptionTypes - SecurityEncryptionTypes enums
type SecurityEncryptionTypes string

const (
	// SecurityEncryptionTypesNonPersistedTPM - NonPersistedTPM
	SecurityEncryptionTypesNonPersistedTPM SecurityEncryptionTypes = "NonPersistedTPM"
	// SecurityEncryptionTypesVMGuestStateOnly - VMGuestStateOnly
	SecurityEncryptionTypesVMGuestStateOnly SecurityEncryptionTypes = "VMGuestStateOnly"
)

// PossibleSecurityEncryptionTypesValues returns the possible values for the SecurityEncryptionTypes const type.
func PossibleSecurityEncryptionTypesValues() []SecurityEncryptionTypes {
	return []SecurityEncryptionTypes{
		SecurityEncryptionTypesNonPersistedTPM,
		SecurityEncryptionTypesVMGuestStateOnly,
	}
}

// SecurityTypes - Specifies the SecurityType of the virtual machine. It has to be set to any specified value to enable UefiSettings.
type SecurityTypes string

const (
	// SecurityTypesConfidentialVM - Azure confidential computing offers confidential VMs are for tenants with high security and
	// confidentiality requirements. These VMs provide a strong, hardware-enforced boundary to help meet your security needs.
	// You can use confidential VMs for migrations without making changes to your code, with the platform protecting your VM's
	// state from being read or modified.
	SecurityTypesConfidentialVM SecurityTypes = "confidentialVM"
	// SecurityTypesTrustedLaunch - Trusted launch protects against advanced and persistent attack techniques.
	SecurityTypesTrustedLaunch SecurityTypes = "trustedLaunch"
)

// PossibleSecurityTypesValues returns the possible values for the SecurityTypes const type.
func PossibleSecurityTypesValues() []SecurityTypes {
	return []SecurityTypes{
		SecurityTypesConfidentialVM,
		SecurityTypesTrustedLaunch,
	}
}

// StartTaskState - BatchStartTaskState enums
type StartTaskState string

const (
	// StartTaskStateCompleted - The StartTask has exited with exit code 0, or the StartTask has failed and the retry limit has
	// reached, or the StartTask process did not run due to Task preparation errors (such as resource file download failures).
	StartTaskStateCompleted StartTaskState = "completed"
	// StartTaskStateRunning - The StartTask is currently running.
	StartTaskStateRunning StartTaskState = "running"
)

// PossibleStartTaskStateValues returns the possible values for the StartTaskState const type.
func PossibleStartTaskStateValues() []StartTaskState {
	return []StartTaskState{
		StartTaskStateCompleted,
		StartTaskStateRunning,
	}
}

// StatusLevelTypes - Level code.
type StatusLevelTypes string

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

// PossibleStatusLevelTypesValues returns the possible values for the StatusLevelTypes const type.
func PossibleStatusLevelTypesValues() []StatusLevelTypes {
	return []StatusLevelTypes{
		StatusLevelTypesError,
		StatusLevelTypesInfo,
		StatusLevelTypesWarning,
	}
}

// StorageAccountType - StorageAccountType enums
type StorageAccountType string

const (
	// StorageAccountTypePremiumLRS - The data disk should use premium locally redundant storage.
	StorageAccountTypePremiumLRS StorageAccountType = "premium_lrs"
	// StorageAccountTypeStandardLRS - The data disk should use standard locally redundant storage.
	StorageAccountTypeStandardLRS StorageAccountType = "standard_lrs"
	// StorageAccountTypeStandardSSDLRS - The data disk / OS disk should use standard SSD locally redundant storage.
	StorageAccountTypeStandardSSDLRS StorageAccountType = "standardssd_lrs"
)

// PossibleStorageAccountTypeValues returns the possible values for the StorageAccountType const type.
func PossibleStorageAccountTypeValues() []StorageAccountType {
	return []StorageAccountType{
		StorageAccountTypePremiumLRS,
		StorageAccountTypeStandardLRS,
		StorageAccountTypeStandardSSDLRS,
	}
}

// SubtaskState - BatchSubtaskState enums
type SubtaskState string

const (
	// SubtaskStateCompleted - The Task is no longer eligible to run, usually because the Task has finished successfully, or the
	// Task has finished unsuccessfully and has exhausted its retry limit. A Task is also marked as completed if an error occurred
	// launching the Task, or when the Task has been terminated.
	SubtaskStateCompleted SubtaskState = "completed"
	// SubtaskStatePreparing - The Task has been assigned to a Compute Node, but is waiting for a required Job Preparation Task
	// to complete on the Compute Node. If the Job Preparation Task succeeds, the Task will move to running. If the Job Preparation
	// Task fails, the Task will return to active and will be eligible to be assigned to a different Compute Node.
	SubtaskStatePreparing SubtaskState = "preparing"
	// SubtaskStateRunning - The Task is running on a Compute Node. This includes task-level preparation such as downloading resource
	// files or deploying Packages specified on the Task - it does not necessarily mean that the Task command line has started
	// executing.
	SubtaskStateRunning SubtaskState = "running"
)

// PossibleSubtaskStateValues returns the possible values for the SubtaskState const type.
func PossibleSubtaskStateValues() []SubtaskState {
	return []SubtaskState{
		SubtaskStateCompleted,
		SubtaskStatePreparing,
		SubtaskStateRunning,
	}
}

// TaskAddStatus - BatchTaskAddStatus enums
type TaskAddStatus string

const (
	// TaskAddStatusClientError - The Task failed to add due to a client error and should not be retried without modifying the
	// request as appropriate.
	TaskAddStatusClientError TaskAddStatus = "clienterror"
	// TaskAddStatusServerError - Task failed to add due to a server error and can be retried without modification.
	TaskAddStatusServerError TaskAddStatus = "servererror"
	// TaskAddStatusSuccess - The Task was added successfully.
	TaskAddStatusSuccess TaskAddStatus = "success"
)

// PossibleTaskAddStatusValues returns the possible values for the TaskAddStatus const type.
func PossibleTaskAddStatusValues() []TaskAddStatus {
	return []TaskAddStatus{
		TaskAddStatusClientError,
		TaskAddStatusServerError,
		TaskAddStatusSuccess,
	}
}

// TaskExecutionResult - BatchTaskExecutionResult enums
type TaskExecutionResult string

const (
	// TaskExecutionResultFailure - There was an error during processing of the Task. The failure may have occurred before the
	// Task process was launched, while the Task process was executing, or after the Task process exited.
	TaskExecutionResultFailure TaskExecutionResult = "failure"
	// TaskExecutionResultSuccess - The Task ran successfully.
	TaskExecutionResultSuccess TaskExecutionResult = "success"
)

// PossibleTaskExecutionResultValues returns the possible values for the TaskExecutionResult const type.
func PossibleTaskExecutionResultValues() []TaskExecutionResult {
	return []TaskExecutionResult{
		TaskExecutionResultFailure,
		TaskExecutionResultSuccess,
	}
}

// TaskState - BatchTaskState enums
type TaskState string

const (
	// TaskStateActive - The Task is queued and able to run, but is not currently assigned to a Compute Node. A Task enters this
	// state when it is created, when it is enabled after being disabled, or when it is awaiting a retry after a failed run.
	TaskStateActive TaskState = "active"
	// TaskStateCompleted - The Task is no longer eligible to run, usually because the Task has finished successfully, or the
	// Task has finished unsuccessfully and has exhausted its retry limit. A Task is also marked as completed if an error occurred
	// launching the Task, or when the Task has been terminated.
	TaskStateCompleted TaskState = "completed"
	// TaskStatePreparing - The Task has been assigned to a Compute Node, but is waiting for a required Job Preparation Task to
	// complete on the Compute Node. If the Job Preparation Task succeeds, the Task will move to running. If the Job Preparation
	// Task fails, the Task will return to active and will be eligible to be assigned to a different Compute Node.
	TaskStatePreparing TaskState = "preparing"
	// TaskStateRunning - The Task is running on a Compute Node. This includes task-level preparation such as downloading resource
	// files or deploying Packages specified on the Task - it does not necessarily mean that the Task command line has started
	// executing.
	TaskStateRunning TaskState = "running"
)

// PossibleTaskStateValues returns the possible values for the TaskState const type.
func PossibleTaskStateValues() []TaskState {
	return []TaskState{
		TaskStateActive,
		TaskStateCompleted,
		TaskStatePreparing,
		TaskStateRunning,
	}
}

// UpgradeMode - UpgradeMode enums
type UpgradeMode string

const (
	// UpgradeModeAutomatic - TAll virtual machines in the scale set are automatically updated at the same time.
	UpgradeModeAutomatic UpgradeMode = "automatic"
	// UpgradeModeManual - You control the application of updates to virtual machines in the scale set. You do this by using the
	// manualUpgrade action.
	UpgradeModeManual UpgradeMode = "manual"
	// UpgradeModeRolling - The existing instances in a scale set are brought down in batches to be upgraded. Once the upgraded
	// batch is complete, the instances will begin taking traffic again and the next batch will begin. This continues until all
	// instances brought up-to-date.
	UpgradeModeRolling UpgradeMode = "rolling"
)

// PossibleUpgradeModeValues returns the possible values for the UpgradeMode const type.
func PossibleUpgradeModeValues() []UpgradeMode {
	return []UpgradeMode{
		UpgradeModeAutomatic,
		UpgradeModeManual,
		UpgradeModeRolling,
	}
}