# pylint: disable=too-many-lines
# 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 AbusePenaltyAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The action of AbusePenalty."""

    THROTTLE = "Throttle"
    """THROTTLE."""
    BLOCK = "Block"
    """BLOCK."""


class ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal
    only APIs.
    """

    INTERNAL = "Internal"
    """Actions are for internal-only APIs."""


class AgentDeploymentProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of an agentic deployment, as an Azure resource."""

    SUCCEEDED = "Succeeded"
    """The deployment was successfully completed."""
    FAILED = "Failed"
    """The deployment failed."""
    CANCELED = "Canceled"
    """The deployment was canceled."""
    CREATING = "Creating"
    """The deployment is being created."""
    UPDATING = "Updating"
    """The deployment is being updated."""
    DELETING = "Deleting"
    """The deployment is being deleted."""


class AgentDeploymentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Current operational state of the agentic functionality represented by this deployment."""

    STARTING = "Starting"
    """The deployment is starting."""
    RUNNING = "Running"
    """The deployment started/is operational."""
    STOPPING = "Stopping"
    """The deployment is being stopped."""
    STOPPED = "Stopped"
    """The deployment was stopped."""
    FAILED = "Failed"
    """The deployment failed."""
    DELETING = "Deleting"
    """The deployment is being deleted."""
    DELETED = "Deleted"
    """The deployment was deleted."""
    UPDATING = "Updating"
    """The deployment is being updated."""


class AgentDeploymentType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the type of deployment for an agent, indicating how the underlying compute and
    network infrastructure is managed.
    """

    MANAGED = "Managed"
    """The underlying infra is managed by the platform in the deployer's subscription."""
    HOSTED = "Hosted"
    """The underlying infra is owned by the platform."""
    CUSTOM = "Custom"
    """The underlying infra is provisioned by the deployer (BYO)."""


class AgenticApplicationProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of an agentic application."""

    SUCCEEDED = "Succeeded"
    """The application was successfully provisioned."""
    FAILED = "Failed"
    """The application provisioning failed."""
    CANCELED = "Canceled"
    """The application provisioning was canceled."""
    CREATING = "Creating"
    """The application is being created."""
    UPDATING = "Updating"
    """The application is being updated."""
    DELETING = "Deleting"
    """The application is being deleted."""


class AgentProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Protocol used by the agent/exposed by a deployment."""

    AGENT = "Agent"
    """Agent protocol (aka Active)."""
    A2_A = "A2A"
    """Agent2Agent standard."""
    RESPONSES = "Responses"
    """OpenAI-compatible."""


class BuiltInAuthorizationScheme(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Authorization scheme type."""

    DEFAULT = "Default"
    """Standard AzureML RBAC."""
    ORGANIZATION_SCOPE = "OrganizationScope"
    """Claim-based, requires membership in the tenant."""
    CHANNELS = "Channels"
    """Channels-specific (AzureBotService) authorization."""
    CUSTOM = "Custom"
    """Custom scheme defined by the application author."""


class ByPassSelection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Setting for trusted services."""

    NONE = "None"
    """NONE."""
    AZURE_SERVICES = "AzureServices"
    """AZURE_SERVICES."""


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

    AGENTS = "Agents"
    """AGENTS."""


class CapabilityHostProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of capability host."""

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


class CommitmentPlanProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the resource at the time the operation was called."""

    ACCEPTED = "Accepted"
    """ACCEPTED."""
    CREATING = "Creating"
    """CREATING."""
    DELETING = "Deleting"
    """DELETING."""
    MOVING = "Moving"
    """MOVING."""
    FAILED = "Failed"
    """FAILED."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    CANCELED = "Canceled"
    """CANCELED."""


class ComputeOperationStatusType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The status type of a compute operation."""

    IN_PROGRESS = "InProgress"
    """The operation is in progress."""
    SUCCEEDED = "Succeeded"
    """The operation has succeeded."""
    FAILED = "Failed"
    """The operation has failed."""
    CANCELED = "Canceled"
    """The operation has been canceled."""


class ComputeProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The provisioning state of a compute resource."""

    ACCEPTED = "Accepted"
    """The resource provisioning request has been accepted."""
    SUCCEEDED = "Succeeded"
    """The resource has been fully provisioned."""
    FAILED = "Failed"
    """The resource provisioning has failed."""
    CANCELED = "Canceled"
    """The resource provisioning was canceled."""
    DELETING = "Deleting"
    """The resource is being deleted."""
    SCALING = "Scaling"
    """The resource is scaling."""
    DISABLED = "Disabled"
    """The resource is disabled."""
    STARTING = "Starting"
    """The compute resource is starting."""
    STOPPING = "Stopping"
    """The compute resource is stopping."""
    RESTARTING = "Restarting"
    """The compute resource is restarting."""
    STOPPED = "Stopped"
    """The compute resource is stopped."""


class ComputeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of compute resource."""

    CLUSTER = "Cluster"
    """Cluster (AKS-backed) compute type."""
    CONTAINER_INSTANCE = "ContainerInstance"
    """Container Instance compute type."""


class ConnectionAuthType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Authentication type of the connection target."""

    PAT = "PAT"
    """PAT."""
    MANAGED_IDENTITY = "ManagedIdentity"
    """MANAGED_IDENTITY."""
    USERNAME_PASSWORD = "UsernamePassword"
    """USERNAME_PASSWORD."""
    NONE = "None"
    """NONE."""
    SAS = "SAS"
    """SAS."""
    ACCOUNT_KEY = "AccountKey"
    """ACCOUNT_KEY."""
    SERVICE_PRINCIPAL = "ServicePrincipal"
    """SERVICE_PRINCIPAL."""
    ACCESS_KEY = "AccessKey"
    """ACCESS_KEY."""
    API_KEY = "ApiKey"
    """API_KEY."""
    CUSTOM_KEYS = "CustomKeys"
    """CUSTOM_KEYS."""
    O_AUTH2 = "OAuth2"
    """O_AUTH2."""
    AAD = "AAD"
    """AAD."""
    DELEGATED_SAS = "DelegatedSAS"
    """DELEGATED_SAS."""
    PROJECT_MANAGED_IDENTITY = "ProjectManagedIdentity"
    """PROJECT_MANAGED_IDENTITY."""
    ACCOUNT_MANAGED_IDENTITY = "AccountManagedIdentity"
    """ACCOUNT_MANAGED_IDENTITY."""
    USER_ENTRA_TOKEN = "UserEntraToken"
    """USER_ENTRA_TOKEN."""
    AGENT_USER_IMPERSONATION = "AgentUserImpersonation"
    """AGENT_USER_IMPERSONATION."""
    AGENTIC_IDENTITY_TOKEN = "AgenticIdentityToken"
    """AGENTIC_IDENTITY_TOKEN."""
    AGENTIC_USER = "AgenticUser"
    """AGENTIC_USER."""


class ConnectionCategory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Category of the connection."""

    PYTHON_FEED = "PythonFeed"
    """PYTHON_FEED."""
    CONTAINER_REGISTRY = "ContainerRegistry"
    """CONTAINER_REGISTRY."""
    GIT = "Git"
    """GIT."""
    S3 = "S3"
    """S3."""
    SNOWFLAKE = "Snowflake"
    """SNOWFLAKE."""
    AZURE_KEY_VAULT = "AzureKeyVault"
    """AZURE_KEY_VAULT."""
    AZURE_SQL_DB = "AzureSqlDb"
    """AZURE_SQL_DB."""
    AZURE_SYNAPSE_ANALYTICS = "AzureSynapseAnalytics"
    """AZURE_SYNAPSE_ANALYTICS."""
    AZURE_MY_SQL_DB = "AzureMySqlDb"
    """AZURE_MY_SQL_DB."""
    AZURE_POSTGRES_DB = "AzurePostgresDb"
    """AZURE_POSTGRES_DB."""
    ADLS_GEN2 = "ADLSGen2"
    """ADLS_GEN2."""
    AZURE_CONTAINER_APP_ENVIRONMENT = "AzureContainerAppEnvironment"
    """AZURE_CONTAINER_APP_ENVIRONMENT."""
    REDIS = "Redis"
    """REDIS."""
    API_KEY = "ApiKey"
    """API_KEY."""
    AZURE_OPEN_AI = "AzureOpenAI"
    """AZURE_OPEN_AI."""
    AI_SERVICES = "AIServices"
    """AI_SERVICES."""
    COGNITIVE_SEARCH = "CognitiveSearch"
    """COGNITIVE_SEARCH."""
    COGNITIVE_SERVICE = "CognitiveService"
    """COGNITIVE_SERVICE."""
    CUSTOM_KEYS = "CustomKeys"
    """CUSTOM_KEYS."""
    AZURE_BLOB = "AzureBlob"
    """AZURE_BLOB."""
    AZURE_STORAGE_ACCOUNT = "AzureStorageAccount"
    """AZURE_STORAGE_ACCOUNT."""
    AZURE_ONE_LAKE = "AzureOneLake"
    """AZURE_ONE_LAKE."""
    COSMOS_DB = "CosmosDb"
    """COSMOS_DB."""
    COSMOS_DB_MONGO_DB_API = "CosmosDbMongoDbApi"
    """COSMOS_DB_MONGO_DB_API."""
    AZURE_DATA_EXPLORER = "AzureDataExplorer"
    """AZURE_DATA_EXPLORER."""
    AZURE_MARIA_DB = "AzureMariaDb"
    """AZURE_MARIA_DB."""
    AZURE_DATABRICKS_DELTA_LAKE = "AzureDatabricksDeltaLake"
    """AZURE_DATABRICKS_DELTA_LAKE."""
    AZURE_SQL_MI = "AzureSqlMi"
    """AZURE_SQL_MI."""
    AZURE_TABLE_STORAGE = "AzureTableStorage"
    """AZURE_TABLE_STORAGE."""
    AMAZON_RDS_FOR_ORACLE = "AmazonRdsForOracle"
    """AMAZON_RDS_FOR_ORACLE."""
    AMAZON_RDS_FOR_SQL_SERVER = "AmazonRdsForSqlServer"
    """AMAZON_RDS_FOR_SQL_SERVER."""
    AMAZON_REDSHIFT = "AmazonRedshift"
    """AMAZON_REDSHIFT."""
    DB2 = "Db2"
    """DB2."""
    DRILL = "Drill"
    """DRILL."""
    GOOGLE_BIG_QUERY = "GoogleBigQuery"
    """GOOGLE_BIG_QUERY."""
    GREENPLUM = "Greenplum"
    """GREENPLUM."""
    HBASE = "Hbase"
    """HBASE."""
    HIVE = "Hive"
    """HIVE."""
    IMPALA = "Impala"
    """IMPALA."""
    INFORMIX = "Informix"
    """INFORMIX."""
    MARIA_DB = "MariaDb"
    """MARIA_DB."""
    MICROSOFT_ACCESS = "MicrosoftAccess"
    """MICROSOFT_ACCESS."""
    MY_SQL = "MySql"
    """MY_SQL."""
    NETEZZA = "Netezza"
    """NETEZZA."""
    ORACLE = "Oracle"
    """ORACLE."""
    PHOENIX = "Phoenix"
    """PHOENIX."""
    POSTGRE_SQL = "PostgreSql"
    """POSTGRE_SQL."""
    PRESTO = "Presto"
    """PRESTO."""
    SAP_OPEN_HUB = "SapOpenHub"
    """SAP_OPEN_HUB."""
    SAP_BW = "SapBw"
    """SAP_BW."""
    SAP_HANA = "SapHana"
    """SAP_HANA."""
    SAP_TABLE = "SapTable"
    """SAP_TABLE."""
    SPARK = "Spark"
    """SPARK."""
    SQL_SERVER = "SqlServer"
    """SQL_SERVER."""
    SYBASE = "Sybase"
    """SYBASE."""
    TERADATA = "Teradata"
    """TERADATA."""
    VERTICA = "Vertica"
    """VERTICA."""
    PINECONE = "Pinecone"
    """PINECONE."""
    DATABRICKS = "Databricks"
    """DATABRICKS."""
    CASSANDRA = "Cassandra"
    """CASSANDRA."""
    COUCHBASE = "Couchbase"
    """COUCHBASE."""
    MONGO_DB_V2 = "MongoDbV2"
    """MONGO_DB_V2."""
    MONGO_DB_ATLAS = "MongoDbAtlas"
    """MONGO_DB_ATLAS."""
    AMAZON_S3_COMPATIBLE = "AmazonS3Compatible"
    """AMAZON_S3_COMPATIBLE."""
    FILE_SERVER = "FileServer"
    """FILE_SERVER."""
    FTP_SERVER = "FtpServer"
    """FTP_SERVER."""
    GOOGLE_CLOUD_STORAGE = "GoogleCloudStorage"
    """GOOGLE_CLOUD_STORAGE."""
    HDFS = "Hdfs"
    """HDFS."""
    ORACLE_CLOUD_STORAGE = "OracleCloudStorage"
    """ORACLE_CLOUD_STORAGE."""
    SFTP = "Sftp"
    """SFTP."""
    GENERIC_HTTP = "GenericHttp"
    """GENERIC_HTTP."""
    O_DATA_REST = "ODataRest"
    """O_DATA_REST."""
    ODBC = "Odbc"
    """ODBC."""
    GENERIC_REST = "GenericRest"
    """GENERIC_REST."""
    REMOTE_TOOL = "RemoteTool"
    """REMOTE_TOOL."""
    AMAZON_MWS = "AmazonMws"
    """AMAZON_MWS."""
    CONCUR = "Concur"
    """CONCUR."""
    DYNAMICS = "Dynamics"
    """DYNAMICS."""
    DYNAMICS_AX = "DynamicsAx"
    """DYNAMICS_AX."""
    DYNAMICS_CRM = "DynamicsCrm"
    """DYNAMICS_CRM."""
    GOOGLE_AD_WORDS = "GoogleAdWords"
    """GOOGLE_AD_WORDS."""
    HUBSPOT = "Hubspot"
    """HUBSPOT."""
    JIRA = "Jira"
    """JIRA."""
    MAGENTO = "Magento"
    """MAGENTO."""
    MARKETO = "Marketo"
    """MARKETO."""
    OFFICE365 = "Office365"
    """OFFICE365."""
    ELOQUA = "Eloqua"
    """ELOQUA."""
    RESPONSYS = "Responsys"
    """RESPONSYS."""
    ORACLE_SERVICE_CLOUD = "OracleServiceCloud"
    """ORACLE_SERVICE_CLOUD."""
    PAY_PAL = "PayPal"
    """PAY_PAL."""
    QUICK_BOOKS = "QuickBooks"
    """QUICK_BOOKS."""
    SALESFORCE = "Salesforce"
    """SALESFORCE."""
    SALESFORCE_SERVICE_CLOUD = "SalesforceServiceCloud"
    """SALESFORCE_SERVICE_CLOUD."""
    SALESFORCE_MARKETING_CLOUD = "SalesforceMarketingCloud"
    """SALESFORCE_MARKETING_CLOUD."""
    SAP_CLOUD_FOR_CUSTOMER = "SapCloudForCustomer"
    """SAP_CLOUD_FOR_CUSTOMER."""
    SAP_ECC = "SapEcc"
    """SAP_ECC."""
    SERVICE_NOW = "ServiceNow"
    """SERVICE_NOW."""
    SHARE_POINT_ONLINE_LIST = "SharePointOnlineList"
    """SHARE_POINT_ONLINE_LIST."""
    SHOPIFY = "Shopify"
    """SHOPIFY."""
    SQUARE = "Square"
    """SQUARE."""
    WEB_TABLE = "WebTable"
    """WEB_TABLE."""
    XERO = "Xero"
    """XERO."""
    ZOHO = "Zoho"
    """ZOHO."""
    GENERIC_CONTAINER_REGISTRY = "GenericContainerRegistry"
    """GENERIC_CONTAINER_REGISTRY."""
    ELASTICSEARCH = "Elasticsearch"
    """ELASTICSEARCH."""
    APP_INSIGHTS = "AppInsights"
    """APP_INSIGHTS."""
    APP_CONFIG = "AppConfig"
    """APP_CONFIG."""
    OPEN_AI = "OpenAI"
    """OPEN_AI."""
    SERP = "Serp"
    """SERP."""
    BING_LLM_SEARCH = "BingLLMSearch"
    """BING_LLM_SEARCH."""
    SERVERLESS = "Serverless"
    """SERVERLESS."""
    MANAGED_ONLINE_ENDPOINT = "ManagedOnlineEndpoint"
    """MANAGED_ONLINE_ENDPOINT."""
    API_MANAGEMENT = "ApiManagement"
    """API_MANAGEMENT."""
    MODEL_GATEWAY = "ModelGateway"
    """MODEL_GATEWAY."""
    GROUNDING_WITH_BING_SEARCH = "GroundingWithBingSearch"
    """GROUNDING_WITH_BING_SEARCH."""
    GROUNDING_WITH_CUSTOM_SEARCH = "GroundingWithCustomSearch"
    """GROUNDING_WITH_CUSTOM_SEARCH."""
    SHAREPOINT = "Sharepoint"
    """SHAREPOINT."""
    MICROSOFT_FABRIC = "MicrosoftFabric"
    """MICROSOFT_FABRIC."""
    POWER_PLATFORM_ENVIRONMENT = "PowerPlatformEnvironment"
    """POWER_PLATFORM_ENVIRONMENT."""
    REMOTE_A2_A = "RemoteA2A"
    """REMOTE_A2_A."""


class ConnectionGroup(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Group based on connection category."""

    AZURE = "Azure"
    """AZURE."""
    AZURE_AI = "AzureAI"
    """AZURE_AI."""
    DATABASE = "Database"
    """DATABASE."""
    NO_SQL = "NoSQL"
    """NO_SQL."""
    FILE = "File"
    """FILE."""
    GENERIC_PROTOCOL = "GenericProtocol"
    """GENERIC_PROTOCOL."""
    SERVICES_AND_APPS = "ServicesAndApps"
    """SERVICES_AND_APPS."""


class ContentLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Level at which content is filtered."""

    LOW = "Low"
    """LOW."""
    MEDIUM = "Medium"
    """MEDIUM."""
    HIGH = "High"
    """HIGH."""


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 DefenderForAISettingState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Defender for AI state on the AI resource."""

    DISABLED = "Disabled"
    """DISABLED."""
    ENABLED = "Enabled"
    """ENABLED."""


class DeploymentModelVersionUpgradeOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Deployment model version upgrade option."""

    ONCE_NEW_DEFAULT_VERSION_AVAILABLE = "OnceNewDefaultVersionAvailable"
    """ONCE_NEW_DEFAULT_VERSION_AVAILABLE."""
    ONCE_CURRENT_VERSION_EXPIRED = "OnceCurrentVersionExpired"
    """ONCE_CURRENT_VERSION_EXPIRED."""
    NO_AUTO_UPGRADE = "NoAutoUpgrade"
    """NO_AUTO_UPGRADE."""


class DeploymentProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the resource at the time the operation was called."""

    ACCEPTED = "Accepted"
    """ACCEPTED."""
    CREATING = "Creating"
    """CREATING."""
    DELETING = "Deleting"
    """DELETING."""
    MOVING = "Moving"
    """MOVING."""
    FAILED = "Failed"
    """FAILED."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    DISABLED = "Disabled"
    """DISABLED."""
    CANCELED = "Canceled"
    """CANCELED."""


class DeploymentScaleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Deployment scale type."""

    STANDARD = "Standard"
    """STANDARD."""
    MANUAL = "Manual"
    """MANUAL."""


class DeploymentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the deployment. Controls whether the deployment is accepting inference requests.
    Use 'Running' for active deployments that process requests, or 'Paused' to temporarily stop
    inference while preserving the deployment configuration.
    """

    RUNNING = "Running"
    """The deployment is running and accepting inference requests."""
    PAUSED = "Paused"
    """The deployment is paused and not accepting inference requests."""


class DeprecationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates whether the deprecation date is a confirmed planned end-of-life date or an estimated
    deprecation date. When 'Planned', the deprecation date represents a confirmed and communicated
    model end-of-life date. When 'Tentative', the deprecation date is an estimated timeline that
    may be subject to change.
    """

    PLANNED = "Planned"
    """PLANNED."""
    TENTATIVE = "Tentative"
    """TENTATIVE."""


class EncryptionScopeProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the resource at the time the operation was called."""

    ACCEPTED = "Accepted"
    """ACCEPTED."""
    CREATING = "Creating"
    """CREATING."""
    DELETING = "Deleting"
    """DELETING."""
    MOVING = "Moving"
    """MOVING."""
    FAILED = "Failed"
    """FAILED."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    CANCELED = "Canceled"
    """CANCELED."""


class EncryptionScopeState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The encryptionScope state."""

    DISABLED = "Disabled"
    """DISABLED."""
    ENABLED = "Enabled"
    """ENABLED."""


class FirewallSku(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Firewall Sku used for FQDN Rules."""

    STANDARD = "Standard"
    """STANDARD."""
    BASIC = "Basic"
    """BASIC."""


class FoundryAutoUpgradeMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Represents the mode for foundry auto-upgrade configuration."""

    ENABLED = "Enabled"
    """Auto-upgrade is enabled."""
    DISABLED = "Disabled"
    """Auto-upgrade is disabled (opted out)."""


class HostingModel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Account hosting model."""

    WEB = "Web"
    """WEB."""
    CONNECTED_CONTAINER = "ConnectedContainer"
    """CONNECTED_CONTAINER."""
    DISCONNECTED_CONTAINER = "DisconnectedContainer"
    """DISCONNECTED_CONTAINER."""
    PROVISIONED_WEB = "ProvisionedWeb"
    """PROVISIONED_WEB."""


class IdentityKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the kind of Entra identity described by this object."""

    AGENT_BLUEPRINT = "AgentBlueprint"
    """Represents a class identity, used for agentic applications."""
    AGENT_INSTANCE = "AgentInstance"
    """Represents an instance identity."""
    AGENTIC_USER = "AgenticUser"
    """Represents an agentic instance identity with user-like traits."""
    MANAGED = "Managed"
    """Represents a classic managed identity."""
    NONE = "None"
    """No identity."""


class IdentityManagementType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enumeration of identity types, from the perspective of management."""

    SYSTEM = "System"
    """Platform-managed identity."""
    USER = "User"
    """User-managed identity."""
    NONE = "None"
    """No identity."""


class IdentityProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Represents the provisioning state of an identity resource."""

    CREATING = "Creating"
    """Identity is being created."""
    UPDATING = "Updating"
    """Identity is being updated."""
    SUCCEEDED = "Succeeded"
    """Identity has been successfully provisioned."""
    FAILED = "Failed"
    """Identity provisioning has failed."""
    CANCELED = "Canceled"
    """Identity provisioning has been canceled."""
    DELETING = "Deleting"
    """Identity is being deleted."""


class IsolationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Isolation mode for the managed network of a cognitive services account."""

    DISABLED = "Disabled"
    """DISABLED."""
    ALLOW_INTERNET_OUTBOUND = "AllowInternetOutbound"
    """ALLOW_INTERNET_OUTBOUND."""
    ALLOW_ONLY_APPROVED_OUTBOUND = "AllowOnlyApprovedOutbound"
    """ALLOW_ONLY_APPROVED_OUTBOUND."""


class KeyName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """key name to generate (Key1|Key2)."""

    KEY1 = "Key1"
    """KEY1."""
    KEY2 = "Key2"
    """KEY2."""


class KeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enumerates the possible value of keySource for Encryption."""

    MICROSOFT_COGNITIVE_SERVICES = "Microsoft.CognitiveServices"
    """MICROSOFT_COGNITIVE_SERVICES."""
    MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
    """MICROSOFT_KEY_VAULT."""


class ManagedNetworkKind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The Kind of the managed network. Users can switch from V1 to V2 for granular access controls,
    but cannot switch back to V1 once V2 is enabled.
    """

    V1 = "V1"
    """V1."""
    V2 = "V2"
    """V2."""


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

    DEFERRED = "Deferred"
    """DEFERRED."""
    UPDATING = "Updating"
    """UPDATING."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""
    DELETING = "Deleting"
    """DELETING."""
    DELETED = "Deleted"
    """DELETED."""


class ManagedNetworkStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status for the managed network of a cognitive services account."""

    INACTIVE = "Inactive"
    """INACTIVE."""
    ACTIVE = "Active"
    """ACTIVE."""


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

    REQUIRED = "Required"
    """REQUIRED."""
    NOT_REQUIRED = "NotRequired"
    """NOT_REQUIRED."""
    NOT_APPLICABLE = "NotApplicable"
    """NOT_APPLICABLE."""


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

    INACTIVE = "Inactive"
    """INACTIVE."""
    ACTIVE = "Active"
    """ACTIVE."""
    NOT_APPLICABLE = "NotApplicable"
    """NOT_APPLICABLE."""


class ModelLifecycleStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Model lifecycle status."""

    STABLE = "Stable"
    """Legacy state. Replaced with GenerallyAvailable going forward."""
    PREVIEW = "Preview"
    """Model is in preview and may be subject to changes."""
    GENERALLY_AVAILABLE = "GenerallyAvailable"
    """Model is generally available for production use."""
    DEPRECATING = "Deprecating"
    """Model is being deprecated and will be removed in the future. Only customers with existing
    deployments can create new deployments with this model."""
    DEPRECATED = "Deprecated"
    """Model has been deprecated, also known as retired, and is no longer supported. Inference calls
    to deployments of models in this lifecycle state will return 410 errors."""
    LEGACY = "Legacy"
    """Model is a legacy version that is no longer recommended for use. Customers should migrate to
    newer models. Check replacementConfig for upgrade information."""


class NetworkRuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The default action when no rule from ipRules and from virtualNetworkRules match. This is only
    used after the bypass property has been evaluated.
    """

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


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

    INBOUND = "Inbound"
    """INBOUND."""
    OUTBOUND = "Outbound"
    """OUTBOUND."""


class Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit
    logs UX. Default value is "user,system".
    """

    USER = "user"
    """Indicates the operation is initiated by a user."""
    SYSTEM = "system"
    """Indicates the operation is initiated by a system."""
    USER_SYSTEM = "user,system"
    """Indicates the operation is initiated by a user or system."""


class PolicyEvaluationOutcome(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The outcome of a policy evaluation."""

    COMPLIANT = "Compliant"
    """The deployment is compliant with all policies."""
    NON_COMPLIANT = "NonCompliant"
    """The deployment violates one or more policies."""
    ERROR = "Error"
    """An error occurred during evaluation."""


class PrivateEndpointConnectionProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """The current provisioning state."""

    SUCCEEDED = "Succeeded"
    """Connection has been provisioned."""
    CREATING = "Creating"
    """Connection is being created."""
    DELETING = "Deleting"
    """Connection is being deleted."""
    FAILED = "Failed"
    """Connection provisioning has failed."""


class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The private endpoint connection status."""

    PENDING = "Pending"
    """Connection waiting for approval or rejection."""
    APPROVED = "Approved"
    """Connection approved."""
    REJECTED = "Rejected"
    """Connection Rejected."""


class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the cognitive services account at the time the operation was called."""

    ACCEPTED = "Accepted"
    """ACCEPTED."""
    CREATING = "Creating"
    """CREATING."""
    DELETING = "Deleting"
    """DELETING."""
    MOVING = "Moving"
    """MOVING."""
    FAILED = "Failed"
    """FAILED."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    CANCELED = "Canceled"
    """CANCELED."""
    RESOLVING_DNS = "ResolvingDNS"
    """RESOLVING_DNS."""


class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not public endpoint access is allowed for this account."""

    ENABLED = "Enabled"
    """ENABLED."""
    DISABLED = "Disabled"
    """DISABLED."""


class QuotaScopeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The quota scope that determines the level at which the quota is applied."""

    REGIONAL = "Regional"
    """REGIONAL."""
    GLOBAL = "Global"
    """GLOBAL."""
    DATA_ZONE = "DataZone"
    """DATA_ZONE."""
    CLASSIC = "Classic"
    """CLASSIC."""


class QuotaUsageStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Cognitive Services account quota usage status."""

    INCLUDED = "Included"
    """INCLUDED."""
    BLOCKED = "Blocked"
    """BLOCKED."""
    IN_OVERAGE = "InOverage"
    """IN_OVERAGE."""
    UNKNOWN = "Unknown"
    """UNKNOWN."""


class RaiActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The action types to apply to the content filters."""

    NONE = "None"
    """NONE."""
    BLOCKING = "BLOCKING"
    """BLOCKING."""
    ANNOTATING = "ANNOTATING"
    """ANNOTATING."""
    HITL = "HITL"
    """HITL."""
    RETRY = "RETRY"
    """RETRY."""


class RaiEgressDefaultAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The default action when no user-defined egress rules match."""

    ALLOW = "Allow"
    """Allow traffic by default when no rules match."""
    DENY = "Deny"
    """Deny traffic by default when no rules match."""


class RaiEgressHeaderOperation(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The operation to apply to a header in a Transform or Rewrite action."""

    SET = "Set"
    """Set or overwrite the header value, creating it if it does not exist."""
    INSERT = "Insert"
    """Add the header only if it is not already present."""
    REMOVE = "Remove"
    """Remove the header if present."""


class RaiEgressMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The enforcement mode for egress rules. If omitted on create, the server defaults to Enforced."""

    ENFORCED = "Enforced"
    """Rules are enforced. Matching traffic is allowed or denied per rule actions."""
    AUDIT = "Audit"
    """Rules are evaluated and logged but not enforced. Traffic is always forwarded regardless of rule
    action. A would-be Deny is logged but not applied. Transform and Rewrite actions are still
    applied to matching traffic (only Deny enforcement is suppressed)."""


class RaiEgressRuleActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The kind of action an egress rule takes when it matches."""

    ALLOW = "Allow"
    """Allow the matched traffic."""
    DENY = "Deny"
    """Deny the matched traffic."""
    TRANSFORM = "Transform"
    """Forward the matched traffic after applying header transforms. Requires at least one header."""
    REWRITE = "Rewrite"
    """Redirect the matched traffic to a new destination, optionally applying header transforms.
    Requires a rewrite target."""


class RaiEgressRuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of an egress rule, determining what kind of traffic matching it performs."""

    FQDN = "Fqdn"
    """Fully qualified domain name (FQDN) based rule matching on host and path patterns."""


class RaiEgressScheme(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """URL scheme for rewrite targets. Only HTTP and HTTPS are supported."""

    HTTP = "http"
    """HTTP scheme."""
    HTTPS = "https"
    """HTTPS scheme."""


class RaiPolicyContentSource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Content source to apply the Content Filters."""

    PROMPT = "Prompt"
    """PROMPT."""
    COMPLETION = "Completion"
    """COMPLETION."""
    PRE_TOOL_CALL = "PreToolCall"
    """PRE_TOOL_CALL."""
    POST_TOOL_CALL = "PostToolCall"
    """POST_TOOL_CALL."""
    PRE_RUN = "PreRun"
    """PRE_RUN."""
    POST_RUN = "PostRun"
    """POST_RUN."""


class RaiPolicyMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Rai policy mode. The enum value mapping is as below: Default = 0, Deferred=1, Blocking=2,
    Asynchronous_filter =3. Please use 'Asynchronous_filter' after 2025-06-01. It is the same as
    'Deferred' in previous version.
    """

    DEFAULT = "Default"
    """DEFAULT."""
    DEFERRED = "Deferred"
    """DEFERRED."""
    BLOCKING = "Blocking"
    """BLOCKING."""
    ASYNCHRONOUS_FILTER = "Asynchronous_filter"
    """ASYNCHRONOUS_FILTER."""


class RaiPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Content Filters policy type."""

    USER_MANAGED = "UserManaged"
    """USER_MANAGED."""
    SYSTEM_MANAGED = "SystemManaged"
    """SYSTEM_MANAGED."""


class ResourceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The identity type."""

    NONE = "None"
    """NONE."""
    SYSTEM_ASSIGNED = "SystemAssigned"
    """SYSTEM_ASSIGNED."""
    USER_ASSIGNED = "UserAssigned"
    """USER_ASSIGNED."""
    SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned"
    """SYSTEM_ASSIGNED_USER_ASSIGNED."""


class ResourceSkuRestrictionsReasonCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The reason for restriction."""

    QUOTA_ID = "QuotaId"
    """QUOTA_ID."""
    NOT_AVAILABLE_FOR_SUBSCRIPTION = "NotAvailableForSubscription"
    """NOT_AVAILABLE_FOR_SUBSCRIPTION."""


class ResourceSkuRestrictionsType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of restrictions."""

    LOCATION = "Location"
    """LOCATION."""
    ZONE = "Zone"
    """ZONE."""


class RoutingMethods(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Multiregion routing methods."""

    PRIORITY = "Priority"
    """PRIORITY."""
    WEIGHTED = "Weighted"
    """WEIGHTED."""
    PERFORMANCE = "Performance"
    """PERFORMANCE."""


class RoutingMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The model-router routing mode that determines how requests are distributed across models."""

    COST = "cost"
    """Route requests to minimize cost while meeting performance requirements."""
    BALANCED = "balanced"
    """Balance cost and quality when routing requests across models."""
    QUALITY = "quality"
    """Route requests to maximize quality regardless of cost."""


class RuleAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The action enum for a managed network outbound rule."""

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


class RuleCategory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Category of a managed network Outbound Rule of a cognitive services account."""

    REQUIRED = "Required"
    """REQUIRED."""
    RECOMMENDED = "Recommended"
    """RECOMMENDED."""
    USER_DEFINED = "UserDefined"
    """USER_DEFINED."""
    DEPENDENCY = "Dependency"
    """DEPENDENCY."""


class RuleStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of a managed network Outbound Rule of a cognitive services account."""

    INACTIVE = "Inactive"
    """INACTIVE."""
    ACTIVE = "Active"
    """ACTIVE."""
    PROVISIONING = "Provisioning"
    """PROVISIONING."""
    DELETING = "Deleting"
    """DELETING."""
    FAILED = "Failed"
    """FAILED."""


class RuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of a managed network Outbound Rule of a cognitive services account."""

    FQDN = "FQDN"
    """FQDN."""
    PRIVATE_ENDPOINT = "PrivateEndpoint"
    """PRIVATE_ENDPOINT."""
    SERVICE_TAG = "ServiceTag"
    """SERVICE_TAG."""


class ScenarioType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies what features in AI Foundry network injection applies to. Currently only supports
    'agent' for agent scenarios. 'none' means no network injection.
    """

    NONE = "none"
    """NONE."""
    AGENT = "agent"
    """AGENT."""


class ServiceTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The service tier for the deployment. Determines the pricing and performance level for request
    processing. Use 'Default' for standard pricing or 'Priority' for higher-priority processing
    with premium pricing. Note: Pause operations are only supported on Standard, DataZoneStandard,
    and GlobalStandard SKUs.
    """

    DEFAULT = "Default"
    """Default service tier meaning the request will be processed with the standard pricing and
    performance for the selected model."""
    PRIORITY = "Priority"
    """Priority service tier meaning the request will be processed with higher pricing and performance
    for the selected model."""


class SkuTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This field is required to be implemented by the Resource Provider if the service has more than
    one tier, but is not required on a PUT.
    """

    FREE = "Free"
    """FREE."""
    BASIC = "Basic"
    """BASIC."""
    STANDARD = "Standard"
    """STANDARD."""
    PREMIUM = "Premium"
    """PREMIUM."""
    ENTERPRISE = "Enterprise"
    """ENTERPRISE."""


class TierUpgradePolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the tier upgrade policy for the subscription."""

    ONCE_UPGRADE_IS_AVAILABLE = "OnceUpgradeIsAvailable"
    """ONCE_UPGRADE_IS_AVAILABLE."""
    NO_AUTO_UPGRADE = "NoAutoUpgrade"
    """NO_AUTO_UPGRADE."""


class TrafficRoutingProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Traffic routing protocol, used to distribute an application's inbound traffic to its
    deployments.
    """

    FIXED_RATIO = "FixedRatio"
    """Percentage based routing."""


class UnitType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The unit of the metric."""

    COUNT = "Count"
    """COUNT."""
    BYTES = "Bytes"
    """BYTES."""
    SECONDS = "Seconds"
    """SECONDS."""
    PERCENT = "Percent"
    """PERCENT."""
    COUNT_PER_SECOND = "CountPerSecond"
    """COUNT_PER_SECOND."""
    BYTES_PER_SECOND = "BytesPerSecond"
    """BYTES_PER_SECOND."""
    MILLISECONDS = "Milliseconds"
    """MILLISECONDS."""


class UpgradeAvailabilityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether an upgrade to the next quota tier is available."""

    AVAILABLE = "Available"
    """AVAILABLE."""
    NOT_AVAILABLE = "NotAvailable"
    """NOT_AVAILABLE."""


class VmPriority(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """VM priority for a compute pool."""

    REGULAR = "Regular"
    """Regular VM priority."""
    LOW_PRIORITY = "LowPriority"
    """Low-priority VM."""
