# coding=utf-8
# --------------------------------------------------------------------------
# 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) Python Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

from enum import Enum
from azure.core import CaseInsensitiveEnumMeta


class AccessRuleDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Direction of Access Rule."""

    INBOUND = "Inbound"
    """Applies to inbound network traffic to the secured resources."""
    OUTBOUND = "Outbound"
    """Applies to outbound network traffic from the secured resources."""


class AccountKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of account key to regenerate."""

    PRIMARY = "Primary"
    """The primary account key."""
    SECONDARY = "Secondary"
    """The secondary account key."""


class AllocationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether the pool is resizing."""

    STEADY = "Steady"
    """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."""
    RESIZING = "Resizing"
    """The pool is resizing; that is, compute nodes are being added to or removed from the pool."""
    STOPPING = "Stopping"
    """The pool was resizing, but the user has requested that the resize be stopped, but the stop
    request has not yet been completed."""


class AuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication mode for the Batch account."""

    SHARED_KEY = "SharedKey"
    """The authentication mode using shared keys."""
    AAD = "AAD"
    """The authentication mode using Microsoft Entra ID."""
    TASK_AUTHENTICATION_TOKEN = "TaskAuthenticationToken"
    """The authentication mode using task authentication tokens."""


class AutoStorageAuthenticationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication mode which the Batch service will use to manage the auto-storage account."""

    STORAGE_KEYS = "StorageKeys"
    """The Batch service will authenticate requests to auto-storage using storage account keys."""
    BATCH_ACCOUNT_MANAGED_IDENTITY = "BatchAccountManagedIdentity"
    """The Batch service will authenticate requests to auto-storage using the managed identity
    assigned to the Batch account."""


class AutoUserScope(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    TASK = "Task"
    """Specifies that the service should create a new user for the task."""
    POOL = "Pool"
    """Specifies that the task runs as the common auto user account which is created on every node in
    a pool."""


class CachingType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of caching to enable for the disk."""

    NONE = "None"
    """The caching mode for the disk is not enabled."""
    READ_ONLY = "ReadOnly"
    """The caching mode for the disk is read only."""
    READ_WRITE = "ReadWrite"
    """The caching mode for the disk is read and write."""


class ComputeNodeDeallocationOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Determines what to do with a node and its running task(s) after it has been selected for
    deallocation.
    """

    REQUEUE = "Requeue"
    """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."""
    TERMINATE = "Terminate"
    """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."""
    TASK_COMPLETION = "TaskCompletion"
    """Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes
    when all tasks have completed."""
    RETAINED_DATA = "RetainedData"
    """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."""


class ComputeNodeFillType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """How tasks should be distributed across compute nodes."""

    SPREAD = "Spread"
    """Tasks should be assigned evenly across all nodes in the pool."""
    PACK = "Pack"
    """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."""


class ContainerHostDataPath(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The paths which will be mounted to container task's container."""

    SHARED = "Shared"
    """The path for multi-instances task to shared their files."""
    STARTUP = "Startup"
    """The path for start task."""
    VFS_MOUNTS = "VfsMounts"
    """The path contains all virtual file systems are mounted on this node."""
    TASK = "Task"
    """The task path."""
    JOB_PREP = "JobPrep"
    """The job-prep task path."""
    APPLICATIONS = "Applications"
    """The applications path."""


class ContainerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The container technology to be used."""

    DOCKER_COMPATIBLE = "DockerCompatible"
    """A Docker compatible container technology will be used to launch the containers."""
    CRI_COMPATIBLE = "CriCompatible"
    """A CRI based technology will be used to launch the containers."""


class ContainerWorkingDirectory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """A flag to indicate where the container task working directory is. The default is
    'taskWorkingDirectory'.
    """

    TASK_WORKING_DIRECTORY = "TaskWorkingDirectory"
    """Use the standard Batch service task working directory, which will contain the Task resource
    files populated by Batch."""
    CONTAINER_IMAGE_DEFAULT = "ContainerImageDefault"
    """Using container image defined working directory. Beware that this directory will not contain
    the resource files downloaded by Batch."""


class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The kind of entity that created the resource."""

    USER = "User"
    """The entity was created by a user."""
    APPLICATION = "Application"
    """The entity was created by an application."""
    MANAGED_IDENTITY = "ManagedIdentity"
    """The entity was created by a managed identity."""
    KEY = "Key"
    """The entity was created by a key."""


class DiffDiskPlacement(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The location where the OS disk should be placed."""

    CACHE_DISK = "CacheDisk"
    """The OS disk will be placed on the cache disk of the VM."""


class DiskEncryptionTarget(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The disks to encrypt on each compute node."""

    OS_DISK = "OsDisk"
    """The OS Disk on the compute node is encrypted."""
    TEMPORARY_DISK = "TemporaryDisk"
    """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."""


class DynamicVNetAssignmentScope(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The scope of dynamic vnet assignment."""

    NONE = "none"
    """No dynamic VNet assignment is enabled."""
    JOB = "job"
    """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."""


class ElevationLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The elevation level of the user."""

    NON_ADMIN = "NonAdmin"
    """The user is a standard user without elevated access."""
    ADMIN = "Admin"
    """The user is a user with elevated access and operates with full Administrator permissions."""


class EndpointAccessDefaultAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Default action for endpoint access. It is only applicable when publicNetworkAccess is enabled."""

    ALLOW = "Allow"
    """Allow client access."""
    DENY = "Deny"
    """Deny client access."""


class HostEndpointSettingsModeTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the access control policy execution mode."""

    AUDIT = "Audit"
    """In Audit mode, the system acts as if it is enforcing the access control policy, including
    emitting access denial entries in the logs but it does not actually deny any requests to host
    endpoints."""
    ENFORCE = "Enforce"
    """Enforce mode is the recommended mode of operation and system will enforce the access control
    policy. This property cannot be used together with 'inVMAccessControlProfileReferenceId'."""


class InboundEndpointProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The protocol of the endpoint."""

    TCP = "TCP"
    """Use TCP for the endpoint."""
    UDP = "UDP"
    """Use UDP for the endpoint."""


class InterNodeCommunicationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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'.
    """

    ENABLED = "Enabled"
    """Enable network communication between virtual machines."""
    DISABLED = "Disabled"
    """Disable network communication between virtual machines."""


class IPAddressProvisioningType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The provisioning type for Public IP Addresses for the Batch Pool."""

    BATCH_MANAGED = "BatchManaged"
    """A public IP will be created and managed by Batch. There may be multiple public IPs depending on
    the size of the Pool."""
    USER_MANAGED = "UserManaged"
    """Public IPs are provided by the user and will be used to provision the Compute Nodes."""
    NO_PUBLIC_IP_ADDRESSES = "NoPublicIPAddresses"
    """No public IP Address will be created for the Compute Nodes in the Pool."""


class IPFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The IP families used to specify IP versions available to the pool."""

    I_PV4 = "IPv4"
    """IPv4 is available to the pool."""
    I_PV6 = "IPv6"
    """IPv6 is available to the pool."""


class IPRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The action when client IP address is matched."""

    ALLOW = "Allow"
    """Allow access for the matched client IP address."""


class IssueType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of issue."""

    UNKNOWN = "Unknown"
    """Unknown issue type."""
    CONFIGURATION_PROPAGATION_FAILURE = "ConfigurationPropagationFailure"
    """An error occurred while applying the network security perimeter (NSP) configuration."""
    MISSING_PERIMETER_CONFIGURATION = "MissingPerimeterConfiguration"
    """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."""
    MISSING_IDENTITY_CONFIGURATION = "MissingIdentityConfiguration"
    """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."""


class JobDefaultOrder(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The order for scheduling tasks from different jobs with the same priority."""

    NONE = "None"
    """Tasks should be scheduled uniformly from all equal-priority jobs for the pool."""
    CREATION_TIME = "CreationTime"
    """If jobs have equal priority, tasks from jobs that were created earlier should be scheduled
    first."""


class KeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the key source."""

    MICROSOFT_BATCH = "Microsoft.Batch"
    """Batch creates and manages the encryption keys used to protect the account data."""
    MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
    """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."""


class LoginMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies login mode for the user. The default value is Interactive."""

    BATCH = "Batch"
    """The LOGON32_LOGON_BATCH Win32 login mode. The batch login mode is recommended for long running
    parallel processes."""
    INTERACTIVE = "Interactive"
    """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."""


class NameAvailabilityReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the reason that a Batch account name could not be used. The Reason element is only
    returned if NameAvailable is false.
    """

    INVALID = "Invalid"
    """The requested name is invalid."""
    ALREADY_EXISTS = "AlreadyExists"
    """The requested name is already in use."""


class NetworkSecurityGroupRuleAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The action that should be taken for a specified IP address, subnet range or tag."""

    ALLOW = "Allow"
    """Allow access."""
    DENY = "Deny"
    """Deny access."""


class NetworkSecurityPerimeterConfigurationProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Provisioning state of a network security perimeter configuration that is being created or
    updated.
    """

    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    CREATING = "Creating"
    """CREATING."""
    UPDATING = "Updating"
    """UPDATING."""
    DELETING = "Deleting"
    """DELETING."""
    ACCEPTED = "Accepted"
    """ACCEPTED."""
    FAILED = "Failed"
    """FAILED."""
    CANCELED = "Canceled"
    """CANCELED."""


class NodePlacementPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The default value is regional."""

    REGIONAL = "Regional"
    """All nodes in the pool will be allocated in the same region."""
    ZONAL = "Zonal"
    """Nodes in the pool will be spread across different zones with best effort balancing."""


class PackageState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The current state of the application package."""

    PENDING = "Pending"
    """The application package has been created but has not yet been activated."""
    ACTIVE = "Active"
    """The application package is ready for use."""


class PoolAllocationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The allocation mode for creating pools in the Batch account."""

    BATCH_SERVICE = "BatchService"
    """Pools will be allocated in subscriptions owned by the Batch service."""
    USER_SUBSCRIPTION = "UserSubscription"
    """Pools will be allocated in a subscription owned by the user."""


class PoolIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of identity used for the Batch Pool."""

    USER_ASSIGNED = "UserAssigned"
    """Batch pool has user assigned identities with it."""
    NONE = "None"
    """Batch pool has no identity associated with it. Setting ``None`` in update pool will remove
    existing identities."""


class PoolProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The current state of the pool."""

    SUCCEEDED = "Succeeded"
    """The pool is available to run tasks subject to the availability of compute nodes."""
    DELETING = "Deleting"
    """The user has requested that the pool be deleted, but the delete operation has not yet
    completed."""


class PrivateEndpointConnectionProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """The provisioning state of the private endpoint connection."""

    CREATING = "Creating"
    """The connection is creating."""
    UPDATING = "Updating"
    """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."""
    DELETING = "Deleting"
    """The connection is deleting."""
    SUCCEEDED = "Succeeded"
    """The connection status is final and is ready for use if Status is Approved."""
    FAILED = "Failed"
    """The user requested that the connection be updated and it failed. You may retry the update
    operation."""
    CANCELLED = "Cancelled"
    """The user has cancelled the connection creation."""


class PrivateLinkServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The status of the Batch private endpoint connection."""

    APPROVED = "Approved"
    """The private endpoint connection is approved and can be used to access Batch account."""
    PENDING = "Pending"
    """The private endpoint connection is pending and cannot be used to access Batch account."""
    REJECTED = "Rejected"
    """The private endpoint connection is rejected and cannot be used to access Batch account."""
    DISCONNECTED = "Disconnected"
    """The private endpoint connection is disconnected and cannot be used to access Batch account."""


class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The provisioned state of the resource."""

    INVALID = "Invalid"
    """The account is in an invalid state."""
    CREATING = "Creating"
    """The account is being created."""
    DELETING = "Deleting"
    """The account is being deleted."""
    SUCCEEDED = "Succeeded"
    """The account has been created and is ready for use."""
    FAILED = "Failed"
    """The last operation for the account is failed."""
    CANCELLED = "Cancelled"
    """The last operation for the account is cancelled."""


class PublicNetworkAccessType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The network access type for operating on the resources in the Batch account."""

    ENABLED = "Enabled"
    """Enables connectivity to Azure Batch through public DNS."""
    DISABLED = "Disabled"
    """Disables public connectivity and enables private connectivity to Azure Batch Service through
    private endpoint resource."""
    SECURED_BY_PERIMETER = "SecuredByPerimeter"
    """Secures connectivity to Azure Batch through NSP configuration."""


class ResourceAssociationAccessMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Access mode of the resource association."""

    ENFORCED = "Enforced"
    """Enforced access mode - traffic to the resource that failed access checks is blocked."""
    LEARNING = "Learning"
    """Learning access mode - traffic to the resource is enabled for analysis but not blocked."""
    AUDIT = "Audit"
    """Audit access mode - traffic to the resource that fails access checks is logged but not blocked."""


class ResourceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of identity used for the Batch account."""

    SYSTEM_ASSIGNED = "SystemAssigned"
    """Batch account has a system assigned identity with it."""
    USER_ASSIGNED = "UserAssigned"
    """Batch account has user assigned identities with it."""
    NONE = "None"
    """Batch account has no identity associated with it. Setting ``None`` in update account will
    remove existing identities."""


class ResourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The result of the request to list operations."""

    MICROSOFT_BATCH_BATCH_ACCOUNTS = "Microsoft.Batch/batchAccounts"
    """The resource type for Microsoft.Batch/batchAccounts."""


class SecurityEncryptionTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the EncryptionType of the managed disk. It is set to DiskWithVMGuestState for
    encryption of the managed disk along with VMGuestState blob, 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.
    """

    NON_PERSISTED_TPM = "NonPersistedTPM"
    """EncryptionType of the managed disk is set to NonPersistedTPM for not persisting firmware state
    in the VMGuestState blob."""
    VM_GUEST_STATE_ONLY = "VMGuestStateOnly"
    """EncryptionType of the managed disk is set to VMGuestStateOnly for encryption of just the
    VMGuestState blob."""
    DISK_WITH_VM_GUEST_STATE = "DiskWithVMGuestState"
    """EncryptionType of the managed disk is set to DiskWithVMGuestState for encryption of the managed
    disk along with VMGuestState blob. It is not supported in data disks."""


class SecurityTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the SecurityType of the virtual machine. It has to be set to any specified value to
    enable UefiSettings.
    """

    TRUSTED_LAUNCH = "trustedLaunch"
    """Trusted launch protects against advanced and persistent attack techniques."""
    CONFIDENTIAL_VM = "confidentialVM"
    """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."""


class Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Severity of the issue."""

    WARNING = "Warning"
    """WARNING."""
    ERROR = "Error"
    """ERROR."""


class StorageAccountType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The storage account type for use in creating data disks or OS disk."""

    STANDARD_LRS = "Standard_LRS"
    """The data disk / OS disk should use standard locally redundant storage."""
    PREMIUM_LRS = "Premium_LRS"
    """The data disk / OS disk should use premium locally redundant storage."""
    STANDARD_SSD_LRS = "StandardSSD_LRS"
    """The data disk / OS disk should use standard SSD locally redundant storage."""


class UpgradeMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the mode of an upgrade to virtual machines in the scale set.<br /><br /> Possible
    values are:<br /><br /> **Manual** - You  control the application of updates to virtual
    machines in the scale set. You do this by using the manualUpgrade action.<br /><br />
    **Automatic** - All virtual machines in the scale set are automatically updated at the same
    time.<br /><br /> **Rolling** - Scale set performs updates in batches with an optional pause
    time in between.
    """

    AUTOMATIC = "automatic"
    """All virtual machines in the scale set are automatically updated at the same time."""
    MANUAL = "manual"
    """You control the application of updates to virtual machines in the scale set. You do this by
    using the manualUpgrade action."""
    ROLLING = "rolling"
    """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."""
