//go:build go1.18
// +build go1.18

// 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. DO NOT EDIT.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package armbatch

const (
	moduleName    = "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/batch/armbatch"
	moduleVersion = "v3.0.0"
)

// AccessRuleDirection - Direction of Access Rule
type AccessRuleDirection string

const (
	// AccessRuleDirectionInbound - Applies to inbound network traffic to the secured resources.
	AccessRuleDirectionInbound AccessRuleDirection = "Inbound"
	// AccessRuleDirectionOutbound - Applies to outbound network traffic from the secured resources
	AccessRuleDirectionOutbound AccessRuleDirection = "Outbound"
)

// PossibleAccessRuleDirectionValues returns the possible values for the AccessRuleDirection const type.
func PossibleAccessRuleDirectionValues() []AccessRuleDirection {
	return []AccessRuleDirection{
		AccessRuleDirectionInbound,
		AccessRuleDirectionOutbound,
	}
}

// AccountKeyType - The type of account key to regenerate.
type AccountKeyType string

const (
	// AccountKeyTypePrimary - The primary account key.
	AccountKeyTypePrimary AccountKeyType = "Primary"
	// AccountKeyTypeSecondary - The secondary account key.
	AccountKeyTypeSecondary AccountKeyType = "Secondary"
)

// PossibleAccountKeyTypeValues returns the possible values for the AccountKeyType const type.
func PossibleAccountKeyTypeValues() []AccountKeyType {
	return []AccountKeyType{
		AccountKeyTypePrimary,
		AccountKeyTypeSecondary,
	}
}

// AllocationState - Whether the pool is resizing.
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 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 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,
	}
}

// AuthenticationMode - The authentication mode for the Batch account.
type AuthenticationMode string

const (
	// AuthenticationModeAAD - The authentication mode using Microsoft Entra ID.
	AuthenticationModeAAD AuthenticationMode = "AAD"
	// AuthenticationModeSharedKey - The authentication mode using shared keys.
	AuthenticationModeSharedKey AuthenticationMode = "SharedKey"
	// AuthenticationModeTaskAuthenticationToken - The authentication mode using task authentication tokens.
	AuthenticationModeTaskAuthenticationToken AuthenticationMode = "TaskAuthenticationToken"
)

// PossibleAuthenticationModeValues returns the possible values for the AuthenticationMode const type.
func PossibleAuthenticationModeValues() []AuthenticationMode {
	return []AuthenticationMode{
		AuthenticationModeAAD,
		AuthenticationModeSharedKey,
		AuthenticationModeTaskAuthenticationToken,
	}
}

// AutoStorageAuthenticationMode - The authentication mode which the Batch service will use to manage the auto-storage account.
type AutoStorageAuthenticationMode string

const (
	// AutoStorageAuthenticationModeBatchAccountManagedIdentity - The Batch service will authenticate requests to auto-storage
	// using the managed identity assigned to the Batch account.
	AutoStorageAuthenticationModeBatchAccountManagedIdentity AutoStorageAuthenticationMode = "BatchAccountManagedIdentity"
	// AutoStorageAuthenticationModeStorageKeys - The Batch service will authenticate requests to auto-storage using storage account
	// keys.
	AutoStorageAuthenticationModeStorageKeys AutoStorageAuthenticationMode = "StorageKeys"
)

// PossibleAutoStorageAuthenticationModeValues returns the possible values for the AutoStorageAuthenticationMode const type.
func PossibleAutoStorageAuthenticationModeValues() []AutoStorageAuthenticationMode {
	return []AutoStorageAuthenticationMode{
		AutoStorageAuthenticationModeBatchAccountManagedIdentity,
		AutoStorageAuthenticationModeStorageKeys,
	}
}

// AutoUserScope - The default value is Pool. If the pool is running Windows a value of Task should be specified if stricter
// isolation between tasks is required. For example, if the task mutates the registry in a way
// which could impact other tasks, or if certificates have been specified on the pool which should not be accessible by normal
// tasks but should be accessible by start tasks.
type AutoUserScope string

const (
	// AutoUserScopePool - Specifies that the task runs as the common auto user account which is created on every 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 - The type of caching to enable for the disk.
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 - The format of the certificate - either Pfx or Cer. If omitted, the default is Pfx.
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,
	}
}

type CertificateProvisioningState string

const (
	// CertificateProvisioningStateDeleting - 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.
	CertificateProvisioningStateDeleting CertificateProvisioningState = "Deleting"
	// CertificateProvisioningStateFailed - 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 compute nodes. (The latter can occur if the
	// certificate has been removed from the pool, but the node has not yet restarted. 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.
	CertificateProvisioningStateFailed CertificateProvisioningState = "Failed"
	// CertificateProvisioningStateSucceeded - The certificate is available for use in pools.
	CertificateProvisioningStateSucceeded CertificateProvisioningState = "Succeeded"
)

// PossibleCertificateProvisioningStateValues returns the possible values for the CertificateProvisioningState const type.
func PossibleCertificateProvisioningStateValues() []CertificateProvisioningState {
	return []CertificateProvisioningState{
		CertificateProvisioningStateDeleting,
		CertificateProvisioningStateFailed,
		CertificateProvisioningStateSucceeded,
	}
}

// CertificateStoreLocation - The default value is currentUser. This property is applicable only for pools configured with
// Windows compute nodes. For Linux compute nodes, the certificates are stored in a directory inside the task
// working directory and an environment variable AZBATCHCERTIFICATES_DIR is supplied to the task to query for this location.
// For certificates with visibility of 'remoteUser', a 'certs' directory is
// created in the user's home directory (e.g., /home/{user-name}/certs) and certificates are placed in that directory.
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,
	}
}

type CertificateVisibility string

const (
	// CertificateVisibilityRemoteUser - The certificate should be visible to the user accounts under which users remotely access
	// the node.
	CertificateVisibilityRemoteUser CertificateVisibility = "RemoteUser"
	// CertificateVisibilityStartTask - The certificate should be visible to the user account under which the start task 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,
	}
}

// ComputeNodeDeallocationOption - Determines what to do with a node and its running task(s) after it has been selected for
// deallocation.
type ComputeNodeDeallocationOption string

const (
	// ComputeNodeDeallocationOptionRequeue - Terminate running task processes and requeue the tasks. The tasks will run again
	// when a node is available. Remove nodes as soon as tasks have been terminated.
	ComputeNodeDeallocationOptionRequeue ComputeNodeDeallocationOption = "Requeue"
	// ComputeNodeDeallocationOptionRetainedData - Allow currently running tasks to complete, then wait for all task data retention
	// periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired.
	ComputeNodeDeallocationOptionRetainedData ComputeNodeDeallocationOption = "RetainedData"
	// ComputeNodeDeallocationOptionTaskCompletion - Allow currently running tasks to complete. Schedule no new tasks while waiting.
	// Remove nodes when all tasks have completed.
	ComputeNodeDeallocationOptionTaskCompletion ComputeNodeDeallocationOption = "TaskCompletion"
	// ComputeNodeDeallocationOptionTerminate - Terminate running tasks. The tasks will be completed with failureInfo indicating
	// that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated.
	ComputeNodeDeallocationOptionTerminate ComputeNodeDeallocationOption = "Terminate"
)

// PossibleComputeNodeDeallocationOptionValues returns the possible values for the ComputeNodeDeallocationOption const type.
func PossibleComputeNodeDeallocationOptionValues() []ComputeNodeDeallocationOption {
	return []ComputeNodeDeallocationOption{
		ComputeNodeDeallocationOptionRequeue,
		ComputeNodeDeallocationOptionRetainedData,
		ComputeNodeDeallocationOptionTaskCompletion,
		ComputeNodeDeallocationOptionTerminate,
	}
}

// ComputeNodeFillType - How tasks should be distributed across compute nodes.
type ComputeNodeFillType string

const (
	// ComputeNodeFillTypePack - As many tasks as possible (taskSlotsPerNode) should be assigned to each node in the pool before
	// any tasks are assigned to the next node in the pool.
	ComputeNodeFillTypePack ComputeNodeFillType = "Pack"
	// ComputeNodeFillTypeSpread - Tasks should be assigned evenly across all nodes in the pool.
	ComputeNodeFillTypeSpread ComputeNodeFillType = "Spread"
)

// PossibleComputeNodeFillTypeValues returns the possible values for the ComputeNodeFillType const type.
func PossibleComputeNodeFillTypeValues() []ComputeNodeFillType {
	return []ComputeNodeFillType{
		ComputeNodeFillTypePack,
		ComputeNodeFillTypeSpread,
	}
}

// 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 - The container technology to be used.
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 - A flag to indicate where the container task working directory is. The default is 'taskWorkingDirectory'.
type ContainerWorkingDirectory string

const (
	// ContainerWorkingDirectoryContainerImageDefault - Using container image defined working directory. 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,
	}
}

// CreatedByType - The type of identity that created the resource.
type CreatedByType string

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

// PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.
func PossibleCreatedByTypeValues() []CreatedByType {
	return []CreatedByType{
		CreatedByTypeApplication,
		CreatedByTypeKey,
		CreatedByTypeManagedIdentity,
		CreatedByTypeUser,
	}
}

// DiskEncryptionTarget - If omitted, no disks on the compute nodes in the pool will be encrypted.
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 - The scope of dynamic vnet assignment.
type DynamicVNetAssignmentScope string

const (
	// DynamicVNetAssignmentScopeJob - Dynamic VNet assignment is done per-job. If this value is set, the network configuration
	// subnet ID must also be set. This feature requires approval before use, please contact support
	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 - The elevation level of the user.
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,
	}
}

// EndpointAccessDefaultAction - Default action for endpoint access. It is only applicable when publicNetworkAccess is enabled.
type EndpointAccessDefaultAction string

const (
	// EndpointAccessDefaultActionAllow - Allow client access.
	EndpointAccessDefaultActionAllow EndpointAccessDefaultAction = "Allow"
	// EndpointAccessDefaultActionDeny - Deny client access.
	EndpointAccessDefaultActionDeny EndpointAccessDefaultAction = "Deny"
)

// PossibleEndpointAccessDefaultActionValues returns the possible values for the EndpointAccessDefaultAction const type.
func PossibleEndpointAccessDefaultActionValues() []EndpointAccessDefaultAction {
	return []EndpointAccessDefaultAction{
		EndpointAccessDefaultActionAllow,
		EndpointAccessDefaultActionDeny,
	}
}

// IPAddressProvisioningType - The provisioning type for Public IP Addresses for the Batch Pool.
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 for the Compute Nodes in the Pool.
	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,
	}
}

// InboundEndpointProtocol - The protocol of the endpoint.
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,
	}
}

// InterNodeCommunicationState - This imposes restrictions on which nodes can be assigned to the pool. Enabling this value
// can reduce the chance of the requested number of nodes to be allocated in the pool. If not specified, this
// value defaults to 'Disabled'.
type InterNodeCommunicationState string

const (
	// InterNodeCommunicationStateDisabled - Disable network communication between virtual machines.
	InterNodeCommunicationStateDisabled InterNodeCommunicationState = "Disabled"
	// InterNodeCommunicationStateEnabled - Enable network communication between virtual machines.
	InterNodeCommunicationStateEnabled InterNodeCommunicationState = "Enabled"
)

// PossibleInterNodeCommunicationStateValues returns the possible values for the InterNodeCommunicationState const type.
func PossibleInterNodeCommunicationStateValues() []InterNodeCommunicationState {
	return []InterNodeCommunicationState{
		InterNodeCommunicationStateDisabled,
		InterNodeCommunicationStateEnabled,
	}
}

// IssueType - Type of issue
type IssueType string

const (
	// IssueTypeConfigurationPropagationFailure - An error occurred while applying the network security perimeter (NSP) configuration.
	IssueTypeConfigurationPropagationFailure IssueType = "ConfigurationPropagationFailure"
	// IssueTypeMissingIdentityConfiguration - An managed identity hasn't been associated with the resource. The resource will
	// still be able to validate inbound traffic from the network security perimeter (NSP) or matching inbound access rules, but
	// it won't be able to perform outbound access as a member of the NSP.
	IssueTypeMissingIdentityConfiguration IssueType = "MissingIdentityConfiguration"
	// IssueTypeMissingPerimeterConfiguration - A network connectivity issue is happening on the resource which could be addressed
	// either by adding new resources to the network security perimeter (NSP) or by modifying access rules.
	IssueTypeMissingPerimeterConfiguration IssueType = "MissingPerimeterConfiguration"
	// IssueTypeUnknown - Unknown issue type
	IssueTypeUnknown IssueType = "Unknown"
)

// PossibleIssueTypeValues returns the possible values for the IssueType const type.
func PossibleIssueTypeValues() []IssueType {
	return []IssueType{
		IssueTypeConfigurationPropagationFailure,
		IssueTypeMissingIdentityConfiguration,
		IssueTypeMissingPerimeterConfiguration,
		IssueTypeUnknown,
	}
}

// KeySource - Type of the key source.
type KeySource string

const (
	// KeySourceMicrosoftBatch - Batch creates and manages the encryption keys used to protect the account data.
	KeySourceMicrosoftBatch KeySource = "Microsoft.Batch"
	// KeySourceMicrosoftKeyVault - The encryption keys used to protect the account data are stored in an external key vault.
	// If this is set then the Batch Account identity must be set to `SystemAssigned` and a valid Key Identifier must also be
	// supplied under the keyVaultProperties.
	KeySourceMicrosoftKeyVault KeySource = "Microsoft.KeyVault"
)

// PossibleKeySourceValues returns the possible values for the KeySource const type.
func PossibleKeySourceValues() []KeySource {
	return []KeySource{
		KeySourceMicrosoftBatch,
		KeySourceMicrosoftKeyVault,
	}
}

// LoginMode - Specifies login mode for the user. The default value is Interactive.
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. Some applications require having permissions associated
	// with the interactive login mode. If this is the case for an application used in your task, then this option is recommended.
	LoginModeInteractive LoginMode = "Interactive"
)

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

// NameAvailabilityReason - Gets the reason that a Batch account name could not be used. The Reason element is only returned
// if NameAvailable is false.
type NameAvailabilityReason string

const (
	// NameAvailabilityReasonAlreadyExists - The requested name is already in use.
	NameAvailabilityReasonAlreadyExists NameAvailabilityReason = "AlreadyExists"
	// NameAvailabilityReasonInvalid - The requested name is invalid.
	NameAvailabilityReasonInvalid NameAvailabilityReason = "Invalid"
)

// PossibleNameAvailabilityReasonValues returns the possible values for the NameAvailabilityReason const type.
func PossibleNameAvailabilityReasonValues() []NameAvailabilityReason {
	return []NameAvailabilityReason{
		NameAvailabilityReasonAlreadyExists,
		NameAvailabilityReasonInvalid,
	}
}

// NetworkSecurityGroupRuleAccess - The action that should be taken for a specified IP address, subnet range or tag.
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,
	}
}

// NetworkSecurityPerimeterConfigurationProvisioningState - Provisioning state of a network security perimeter configuration
// that is being created or updated.
type NetworkSecurityPerimeterConfigurationProvisioningState string

const (
	NetworkSecurityPerimeterConfigurationProvisioningStateAccepted  NetworkSecurityPerimeterConfigurationProvisioningState = "Accepted"
	NetworkSecurityPerimeterConfigurationProvisioningStateCanceled  NetworkSecurityPerimeterConfigurationProvisioningState = "Canceled"
	NetworkSecurityPerimeterConfigurationProvisioningStateCreating  NetworkSecurityPerimeterConfigurationProvisioningState = "Creating"
	NetworkSecurityPerimeterConfigurationProvisioningStateDeleting  NetworkSecurityPerimeterConfigurationProvisioningState = "Deleting"
	NetworkSecurityPerimeterConfigurationProvisioningStateFailed    NetworkSecurityPerimeterConfigurationProvisioningState = "Failed"
	NetworkSecurityPerimeterConfigurationProvisioningStateSucceeded NetworkSecurityPerimeterConfigurationProvisioningState = "Succeeded"
	NetworkSecurityPerimeterConfigurationProvisioningStateUpdating  NetworkSecurityPerimeterConfigurationProvisioningState = "Updating"
)

// PossibleNetworkSecurityPerimeterConfigurationProvisioningStateValues returns the possible values for the NetworkSecurityPerimeterConfigurationProvisioningState const type.
func PossibleNetworkSecurityPerimeterConfigurationProvisioningStateValues() []NetworkSecurityPerimeterConfigurationProvisioningState {
	return []NetworkSecurityPerimeterConfigurationProvisioningState{
		NetworkSecurityPerimeterConfigurationProvisioningStateAccepted,
		NetworkSecurityPerimeterConfigurationProvisioningStateCanceled,
		NetworkSecurityPerimeterConfigurationProvisioningStateCreating,
		NetworkSecurityPerimeterConfigurationProvisioningStateDeleting,
		NetworkSecurityPerimeterConfigurationProvisioningStateFailed,
		NetworkSecurityPerimeterConfigurationProvisioningStateSucceeded,
		NetworkSecurityPerimeterConfigurationProvisioningStateUpdating,
	}
}

// NodeCommunicationMode - Determines how a pool communicates with the Batch service.
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,
	}
}

// NodePlacementPolicyType - The default value is regional.
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 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,
	}
}

// PackageState - The current state of the application package.
type PackageState string

const (
	// PackageStateActive - The application package is ready for use.
	PackageStateActive PackageState = "Active"
	// PackageStatePending - The application package has been created but has not yet been activated.
	PackageStatePending PackageState = "Pending"
)

// PossiblePackageStateValues returns the possible values for the PackageState const type.
func PossiblePackageStateValues() []PackageState {
	return []PackageState{
		PackageStateActive,
		PackageStatePending,
	}
}

// PoolAllocationMode - The allocation mode for creating pools in the Batch account.
type PoolAllocationMode string

const (
	// PoolAllocationModeBatchService - Pools will be allocated in subscriptions owned by the Batch service.
	PoolAllocationModeBatchService PoolAllocationMode = "BatchService"
	// PoolAllocationModeUserSubscription - Pools will be allocated in a subscription owned by the user.
	PoolAllocationModeUserSubscription PoolAllocationMode = "UserSubscription"
)

// PossiblePoolAllocationModeValues returns the possible values for the PoolAllocationMode const type.
func PossiblePoolAllocationModeValues() []PoolAllocationMode {
	return []PoolAllocationMode{
		PoolAllocationModeBatchService,
		PoolAllocationModeUserSubscription,
	}
}

// PoolIdentityType - The type of identity used for the Batch Pool.
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,
	}
}

// PoolProvisioningState - The current state of the pool.
type PoolProvisioningState string

const (
	// PoolProvisioningStateDeleting - The user has requested that the pool be deleted, but the delete operation has not yet completed.
	PoolProvisioningStateDeleting PoolProvisioningState = "Deleting"
	// PoolProvisioningStateSucceeded - The pool is available to run tasks subject to the availability of compute nodes.
	PoolProvisioningStateSucceeded PoolProvisioningState = "Succeeded"
)

// PossiblePoolProvisioningStateValues returns the possible values for the PoolProvisioningState const type.
func PossiblePoolProvisioningStateValues() []PoolProvisioningState {
	return []PoolProvisioningState{
		PoolProvisioningStateDeleting,
		PoolProvisioningStateSucceeded,
	}
}

// PrivateEndpointConnectionProvisioningState - The provisioning state of the private endpoint connection.
type PrivateEndpointConnectionProvisioningState string

const (
	// PrivateEndpointConnectionProvisioningStateCancelled - The user has cancelled the connection creation.
	PrivateEndpointConnectionProvisioningStateCancelled PrivateEndpointConnectionProvisioningState = "Cancelled"
	// PrivateEndpointConnectionProvisioningStateCreating - The connection is creating.
	PrivateEndpointConnectionProvisioningStateCreating PrivateEndpointConnectionProvisioningState = "Creating"
	// PrivateEndpointConnectionProvisioningStateDeleting - The connection is deleting.
	PrivateEndpointConnectionProvisioningStateDeleting PrivateEndpointConnectionProvisioningState = "Deleting"
	// PrivateEndpointConnectionProvisioningStateFailed - The user requested that the connection be updated and it failed. You
	// may retry the update operation.
	PrivateEndpointConnectionProvisioningStateFailed PrivateEndpointConnectionProvisioningState = "Failed"
	// PrivateEndpointConnectionProvisioningStateSucceeded - The connection status is final and is ready for use if Status is
	// Approved.
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
	// PrivateEndpointConnectionProvisioningStateUpdating - The user has requested that the connection status be updated, but
	// the update operation has not yet completed. You may not reference the connection when connecting the Batch account.
	PrivateEndpointConnectionProvisioningStateUpdating PrivateEndpointConnectionProvisioningState = "Updating"
)

// PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.
func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState {
	return []PrivateEndpointConnectionProvisioningState{
		PrivateEndpointConnectionProvisioningStateCancelled,
		PrivateEndpointConnectionProvisioningStateCreating,
		PrivateEndpointConnectionProvisioningStateDeleting,
		PrivateEndpointConnectionProvisioningStateFailed,
		PrivateEndpointConnectionProvisioningStateSucceeded,
		PrivateEndpointConnectionProvisioningStateUpdating,
	}
}

// PrivateLinkServiceConnectionStatus - The status of the Batch private endpoint connection
type PrivateLinkServiceConnectionStatus string

const (
	// PrivateLinkServiceConnectionStatusApproved - The private endpoint connection is approved and can be used to access Batch
	// account
	PrivateLinkServiceConnectionStatusApproved PrivateLinkServiceConnectionStatus = "Approved"
	// PrivateLinkServiceConnectionStatusDisconnected - The private endpoint connection is disconnected and cannot be used to
	// access Batch account
	PrivateLinkServiceConnectionStatusDisconnected PrivateLinkServiceConnectionStatus = "Disconnected"
	// PrivateLinkServiceConnectionStatusPending - The private endpoint connection is pending and cannot be used to access Batch
	// account
	PrivateLinkServiceConnectionStatusPending PrivateLinkServiceConnectionStatus = "Pending"
	// PrivateLinkServiceConnectionStatusRejected - The private endpoint connection is rejected and cannot be used to access Batch
	// account
	PrivateLinkServiceConnectionStatusRejected PrivateLinkServiceConnectionStatus = "Rejected"
)

// PossiblePrivateLinkServiceConnectionStatusValues returns the possible values for the PrivateLinkServiceConnectionStatus const type.
func PossiblePrivateLinkServiceConnectionStatusValues() []PrivateLinkServiceConnectionStatus {
	return []PrivateLinkServiceConnectionStatus{
		PrivateLinkServiceConnectionStatusApproved,
		PrivateLinkServiceConnectionStatusDisconnected,
		PrivateLinkServiceConnectionStatusPending,
		PrivateLinkServiceConnectionStatusRejected,
	}
}

// ProvisioningState - The provisioned state of the resource
type ProvisioningState string

const (
	// ProvisioningStateCancelled - The last operation for the account is cancelled.
	ProvisioningStateCancelled ProvisioningState = "Cancelled"
	// ProvisioningStateCreating - The account is being created.
	ProvisioningStateCreating ProvisioningState = "Creating"
	// ProvisioningStateDeleting - The account is being deleted.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - The last operation for the account is failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateInvalid - The account is in an invalid state.
	ProvisioningStateInvalid ProvisioningState = "Invalid"
	// ProvisioningStateSucceeded - The account has been created and is ready for use.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.
func PossibleProvisioningStateValues() []ProvisioningState {
	return []ProvisioningState{
		ProvisioningStateCancelled,
		ProvisioningStateCreating,
		ProvisioningStateDeleting,
		ProvisioningStateFailed,
		ProvisioningStateInvalid,
		ProvisioningStateSucceeded,
	}
}

// PublicNetworkAccessType - The network access type for operating on the resources in the Batch account.
type PublicNetworkAccessType string

const (
	// PublicNetworkAccessTypeDisabled - Disables public connectivity and enables private connectivity to Azure Batch Service
	// through private endpoint resource.
	PublicNetworkAccessTypeDisabled PublicNetworkAccessType = "Disabled"
	// PublicNetworkAccessTypeEnabled - Enables connectivity to Azure Batch through public DNS.
	PublicNetworkAccessTypeEnabled PublicNetworkAccessType = "Enabled"
	// PublicNetworkAccessTypeSecuredByPerimeter - Secures connectivity to Azure Batch through NSP configuration.
	PublicNetworkAccessTypeSecuredByPerimeter PublicNetworkAccessType = "SecuredByPerimeter"
)

// PossiblePublicNetworkAccessTypeValues returns the possible values for the PublicNetworkAccessType const type.
func PossiblePublicNetworkAccessTypeValues() []PublicNetworkAccessType {
	return []PublicNetworkAccessType{
		PublicNetworkAccessTypeDisabled,
		PublicNetworkAccessTypeEnabled,
		PublicNetworkAccessTypeSecuredByPerimeter,
	}
}

// ResourceAssociationAccessMode - Access mode of the resource association
type ResourceAssociationAccessMode string

const (
	// ResourceAssociationAccessModeAudit - Audit access mode - traffic to the resource that fails access checks is logged but
	// not blocked
	ResourceAssociationAccessModeAudit ResourceAssociationAccessMode = "Audit"
	// ResourceAssociationAccessModeEnforced - Enforced access mode - traffic to the resource that failed access checks is blocked
	ResourceAssociationAccessModeEnforced ResourceAssociationAccessMode = "Enforced"
	// ResourceAssociationAccessModeLearning - Learning access mode - traffic to the resource is enabled for analysis but not
	// blocked
	ResourceAssociationAccessModeLearning ResourceAssociationAccessMode = "Learning"
)

// PossibleResourceAssociationAccessModeValues returns the possible values for the ResourceAssociationAccessMode const type.
func PossibleResourceAssociationAccessModeValues() []ResourceAssociationAccessMode {
	return []ResourceAssociationAccessMode{
		ResourceAssociationAccessModeAudit,
		ResourceAssociationAccessModeEnforced,
		ResourceAssociationAccessModeLearning,
	}
}

// ResourceIdentityType - The type of identity used for the Batch account.
type ResourceIdentityType string

const (
	// ResourceIdentityTypeNone - Batch account has no identity associated with it. Setting `None` in update account will remove
	// existing identities.
	ResourceIdentityTypeNone ResourceIdentityType = "None"
	// ResourceIdentityTypeSystemAssigned - Batch account has a system assigned identity with it.
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
	// ResourceIdentityTypeUserAssigned - Batch account has user assigned identities with it.
	ResourceIdentityTypeUserAssigned ResourceIdentityType = "UserAssigned"
)

// PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.
func PossibleResourceIdentityTypeValues() []ResourceIdentityType {
	return []ResourceIdentityType{
		ResourceIdentityTypeNone,
		ResourceIdentityTypeSystemAssigned,
		ResourceIdentityTypeUserAssigned,
	}
}

// SecurityEncryptionTypes - Specifies the EncryptionType of the managed disk. It is set to VMGuestStateOnly for encryption
// of just the VMGuestState blob, and NonPersistedTPM for not persisting firmware state in the VMGuestState
// blob. Note: It can be set for only Confidential VMs and required when using Confidential VMs.
type SecurityEncryptionTypes string

const (
	SecurityEncryptionTypesNonPersistedTPM  SecurityEncryptionTypes = "NonPersistedTPM"
	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,
	}
}

// Severity - Severity of the issue.
type Severity string

const (
	SeverityError   Severity = "Error"
	SeverityWarning Severity = "Warning"
)

// PossibleSeverityValues returns the possible values for the Severity const type.
func PossibleSeverityValues() []Severity {
	return []Severity{
		SeverityError,
		SeverityWarning,
	}
}

// StorageAccountType - The storage account type for use in creating data disks or OS disk.
type StorageAccountType string

const (
	// StorageAccountTypePremiumLRS - The data disk / OS disk should use premium locally redundant storage.
	StorageAccountTypePremiumLRS StorageAccountType = "Premium_LRS"
	// StorageAccountTypeStandardLRS - The data disk / OS 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,
	}
}

// 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.
// Rolling - Scale set performs updates in batches with an optional pause time in between.
type UpgradeMode string

const (
	// UpgradeModeAutomatic - All 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,
	}
}
