# 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 ActivityOnInactiveMarkAs(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status result of the activity when the state is set to Inactive. This is an optional property
    and if not provided when the activity is inactive, the status will be Succeeded by default.
    """

    SUCCEEDED = "Succeeded"
    """Succeeded."""
    FAILED = "Failed"
    """Failed."""
    SKIPPED = "Skipped"
    """Skipped."""


class ActivityState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Activity state. This is an optional property and if not provided, the state will be Active by
    default.
    """

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


class AmazonRdsForOracleAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Authentication type for connecting to the AmazonRdsForOracle database. Only used for Version
    2.0.
    """

    BASIC = "Basic"
    """Basic."""


class AmazonRdsForSqlAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    SQL = "SQL"
    """SQL."""
    WINDOWS = "Windows"
    """Windows."""


class AzureFunctionActivityMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The list of HTTP methods supported by a AzureFunctionActivity."""

    GET = "GET"
    """GET."""
    POST = "POST"
    """POST."""
    PUT = "PUT"
    """PUT."""
    DELETE = "DELETE"
    """DELETE."""
    OPTIONS = "OPTIONS"
    """OPTIONS."""
    HEAD = "HEAD"
    """HEAD."""
    TRACE = "TRACE"
    """TRACE."""


class AzurePostgreSqlWriteMethodEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The write behavior for the operation. Default is Bulk Insert."""

    BULK_INSERT = "BulkInsert"
    """BulkInsert."""
    COPY_COMMAND = "CopyCommand"
    """CopyCommand."""
    UPSERT = "Upsert"
    """Upsert."""


class AzureSearchIndexWriteBehaviorType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specify the write behavior when upserting documents into Azure Search Index."""

    MERGE = "Merge"
    """Merge."""
    UPLOAD = "Upload"
    """Upload."""


class AzureSqlDatabaseAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    SQL = "SQL"
    """SQL."""
    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class AzureSqlDWAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    SQL = "SQL"
    """SQL."""
    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class AzureSqlMIAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    SQL = "SQL"
    """SQL."""
    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class AzureStorageAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    ACCOUNT_KEY = "AccountKey"
    """AccountKey."""
    SAS_URI = "SasUri"
    """SasUri."""
    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    MSI = "Msi"
    """Msi."""


class BigDataPoolReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Big data pool reference type."""

    BIG_DATA_POOL_REFERENCE = "BigDataPoolReference"
    """BigDataPoolReference."""


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

    MICROSOFT_STORAGE_BLOB_CREATED = "Microsoft.Storage.BlobCreated"
    """Microsoft.Storage.BlobCreated."""
    MICROSOFT_STORAGE_BLOB_DELETED = "Microsoft.Storage.BlobDeleted"
    """Microsoft.Storage.BlobDeleted."""


class CassandraSourceReadConsistencyLevels(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The consistency level specifies how many Cassandra servers must respond to a read request
    before returning data to the client application. Cassandra checks the specified number of
    Cassandra servers for data to satisfy the read request. Must be one of
    cassandraSourceReadConsistencyLevels. The default value is 'ONE'. It is case-insensitive.
    """

    ALL = "ALL"
    """ALL."""
    EACH_QUORUM = "EACH_QUORUM"
    """EACH_QUORUM."""
    QUORUM = "QUORUM"
    """QUORUM."""
    LOCAL_QUORUM = "LOCAL_QUORUM"
    """LOCAL_QUORUM."""
    ONE = "ONE"
    """ONE."""
    TWO = "TWO"
    """TWO."""
    THREE = "THREE"
    """THREE."""
    LOCAL_ONE = "LOCAL_ONE"
    """LOCAL_ONE."""
    SERIAL = "SERIAL"
    """SERIAL."""
    LOCAL_SERIAL = "LOCAL_SERIAL"
    """LOCAL_SERIAL."""


class ConfigurationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the spark config."""

    DEFAULT = "Default"
    """Default."""
    CUSTOMIZED = "Customized"
    """Customized."""
    ARTIFACT = "Artifact"
    """Artifact."""


class ConnectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of connection via linked service or dataset."""

    LINKEDSERVICETYPE = "linkedservicetype"
    """linkedservicetype."""


class CosmosDbConnectionMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The connection mode used to access CosmosDB account. Type: string."""

    GATEWAY = "Gateway"
    """Gateway."""
    DIRECT = "Direct"
    """Direct."""


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 CredentialReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Credential reference type."""

    CREDENTIAL_REFERENCE = "CredentialReference"
    """CredentialReference."""


class DataFlowComputeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Compute type of the cluster which will execute data flow job."""

    GENERAL = "General"
    """General."""
    MEMORY_OPTIMIZED = "MemoryOptimized"
    """MemoryOptimized."""
    COMPUTE_OPTIMIZED = "ComputeOptimized"
    """ComputeOptimized."""


class DataFlowDebugCommandType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The command type."""

    EXECUTE_PREVIEW_QUERY = "executePreviewQuery"
    """executePreviewQuery."""
    EXECUTE_STATISTICS_QUERY = "executeStatisticsQuery"
    """executeStatisticsQuery."""
    EXECUTE_EXPRESSION_QUERY = "executeExpressionQuery"
    """executeExpressionQuery."""


class DataFlowReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Data flow reference type."""

    DATA_FLOW_REFERENCE = "DataFlowReference"
    """DataFlowReference."""


class DatasetReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Dataset reference type."""

    DATASET_REFERENCE = "DatasetReference"
    """DatasetReference."""


class DayOfWeek(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The days of the week."""

    SUNDAY = "Sunday"
    """Sunday."""
    MONDAY = "Monday"
    """Monday."""
    TUESDAY = "Tuesday"
    """Tuesday."""
    WEDNESDAY = "Wednesday"
    """Wednesday."""
    THURSDAY = "Thursday"
    """Thursday."""
    FRIDAY = "Friday"
    """Friday."""
    SATURDAY = "Saturday"
    """Saturday."""


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

    SUNDAY = "Sunday"
    """Sunday."""
    MONDAY = "Monday"
    """Monday."""
    TUESDAY = "Tuesday"
    """Tuesday."""
    WEDNESDAY = "Wednesday"
    """Wednesday."""
    THURSDAY = "Thursday"
    """Thursday."""
    FRIDAY = "Friday"
    """Friday."""
    SATURDAY = "Saturday"
    """Saturday."""


class Db2AuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """AuthenticationType to be used for connection. It is mutually exclusive with connectionString
    property.
    """

    BASIC = "Basic"
    """Basic."""


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

    SUCCEEDED = "Succeeded"
    """Succeeded."""
    FAILED = "Failed"
    """Failed."""
    SKIPPED = "Skipped"
    """Skipped."""
    COMPLETED = "Completed"
    """Completed."""


class DynamicsSinkWriteBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Defines values for DynamicsSinkWriteBehavior."""

    UPSERT = "Upsert"
    """Upsert."""


class EventSubscriptionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Event Subscription Status."""

    ENABLED = "Enabled"
    """Enabled."""
    PROVISIONING = "Provisioning"
    """Provisioning."""
    DEPROVISIONING = "Deprovisioning"
    """Deprovisioning."""
    DISABLED = "Disabled"
    """Disabled."""
    UNKNOWN = "Unknown"
    """Unknown."""


class ExpressionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Expression type."""

    EXPRESSION = "Expression"
    """Expression."""


class ExpressionV2Type(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of expressions supported by the system. Type: string."""

    CONSTANT = "Constant"
    """Constant."""
    FIELD = "Field"
    """Field."""
    UNARY = "Unary"
    """Unary."""
    BINARY = "Binary"
    """Binary."""
    N_ARY = "NAry"
    """NAry."""


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

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


class FrequencyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Frequency of period in terms of 'Hour', 'Minute' or 'Second'."""

    HOUR = "Hour"
    """Hour."""
    MINUTE = "Minute"
    """Minute."""
    SECOND = "Second"
    """Second."""


class FtpAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to be used to connect to the FTP server."""

    BASIC = "Basic"
    """Basic."""
    ANONYMOUS = "Anonymous"
    """Anonymous."""


class GlobalParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Global Parameter type."""

    OBJECT = "Object"
    """Object."""
    STRING = "String"
    """String."""
    INT = "Int"
    """Int."""
    FLOAT = "Float"
    """Float."""
    BOOL = "Bool"
    """Bool."""
    ARRAY = "Array"
    """Array."""


class GoogleAdWordsAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The OAuth 2.0 authentication mechanism used for authentication. ServiceAuthentication can only
    be used on self-hosted IR.
    """

    SERVICE_AUTHENTICATION = "ServiceAuthentication"
    """ServiceAuthentication."""
    USER_AUTHENTICATION = "UserAuthentication"
    """UserAuthentication."""


class GoogleBigQueryAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The OAuth 2.0 authentication mechanism used for authentication. ServiceAuthentication can only
    be used on self-hosted IR.
    """

    SERVICE_AUTHENTICATION = "ServiceAuthentication"
    """ServiceAuthentication."""
    USER_AUTHENTICATION = "UserAuthentication"
    """UserAuthentication."""


class GoogleBigQueryV2AuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The OAuth 2.0 authentication mechanism used for authentication."""

    SERVICE_AUTHENTICATION = "ServiceAuthentication"
    """ServiceAuthentication."""
    USER_AUTHENTICATION = "UserAuthentication"
    """UserAuthentication."""


class GreenplumAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use. Type: string. Only used for V2."""

    BASIC = "Basic"
    """Basic."""


class HBaseAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication mechanism to use to connect to the HBase server."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    BASIC = "Basic"
    """Basic."""


class HDInsightActivityDebugInfoOption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The HDInsightActivityDebugInfoOption settings to use."""

    NONE = "None"
    """None."""
    ALWAYS = "Always"
    """Always."""
    FAILURE = "Failure"
    """Failure."""


class HDInsightClusterAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """HDInsight cluster authentication type."""

    BASIC_AUTH = "BasicAuth"
    """BasicAuth."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class HDInsightOndemandClusterResourceGroupAuthenticationType(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """HDInsight On-demand cluster resource group authentication type."""

    SERVICE_PRINCIPAL_KEY = "ServicePrincipalKey"
    """ServicePrincipalKey."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class HiveAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication method used to access the Hive server."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    USERNAME = "Username"
    """Username."""
    USERNAME_AND_PASSWORD = "UsernameAndPassword"
    """UsernameAndPassword."""
    WINDOWS_AZURE_HD_INSIGHT_SERVICE = "WindowsAzureHDInsightService"
    """WindowsAzureHDInsightService."""


class HiveServerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of Hive server."""

    HIVE_SERVER1 = "HiveServer1"
    """HiveServer1."""
    HIVE_SERVER2 = "HiveServer2"
    """HiveServer2."""
    HIVE_THRIFT_SERVER = "HiveThriftServer"
    """HiveThriftServer."""


class HiveThriftTransportProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The transport protocol to use in the Thrift layer."""

    BINARY = "Binary"
    """Binary."""
    SASL = "SASL"
    """SASL."""
    HTTP = "HTTP "
    """HTTP."""


class HttpAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to be used to connect to the HTTP server."""

    BASIC = "Basic"
    """Basic."""
    ANONYMOUS = "Anonymous"
    """Anonymous."""
    DIGEST = "Digest"
    """Digest."""
    WINDOWS = "Windows"
    """Windows."""
    CLIENT_CERTIFICATE = "ClientCertificate"
    """ClientCertificate."""


class ImpalaAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    SASL_USERNAME = "SASLUsername"
    """SASLUsername."""
    USERNAME_AND_PASSWORD = "UsernameAndPassword"
    """UsernameAndPassword."""


class ImpalaThriftTransportProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The transport protocol to use in the Thrift layer (for V2 only). Default value is Binary."""

    BINARY = "Binary"
    """Binary."""
    HTTP = "HTTP"
    """HTTP."""


class IntegrationRuntimeAuthKeyName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The name of the authentication key to regenerate."""

    AUTH_KEY1 = "authKey1"
    """authKey1."""
    AUTH_KEY2 = "authKey2"
    """authKey2."""


class IntegrationRuntimeAutoUpdate(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of integration runtime auto update."""

    ON = "On"
    """On."""
    OFF = "Off"
    """Off."""


class IntegrationRuntimeEdition(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The edition for the SSIS Integration Runtime."""

    STANDARD = "Standard"
    """Standard."""
    ENTERPRISE = "Enterprise"
    """Enterprise."""


class IntegrationRuntimeEntityReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of this referenced entity."""

    INTEGRATION_RUNTIME_REFERENCE = "IntegrationRuntimeReference"
    """IntegrationRuntimeReference."""
    LINKED_SERVICE_REFERENCE = "LinkedServiceReference"
    """LinkedServiceReference."""


class IntegrationRuntimeInternalChannelEncryptionMode(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """It is used to set the encryption mode for node-node communication channel (when more than 2
    self-hosted integration runtime nodes exist).
    """

    NOT_SET = "NotSet"
    """NotSet."""
    SSL_ENCRYPTED = "SslEncrypted"
    """SslEncrypted."""
    NOT_ENCRYPTED = "NotEncrypted"
    """NotEncrypted."""


class IntegrationRuntimeLicenseType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """License type for bringing your own license scenario."""

    BASE_PRICE = "BasePrice"
    """BasePrice."""
    LICENSE_INCLUDED = "LicenseIncluded"
    """LicenseIncluded."""


class IntegrationRuntimeReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of integration runtime."""

    INTEGRATION_RUNTIME_REFERENCE = "IntegrationRuntimeReference"
    """IntegrationRuntimeReference."""


class IntegrationRuntimeSsisCatalogPricingTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The pricing tier for the catalog database. The valid values could be found in
    `https://azure.microsoft.com/en-us/pricing/details/sql-database/
    <https://azure.microsoft.com/en-us/pricing/details/sql-database/>`_.
    """

    BASIC = "Basic"
    """Basic."""
    STANDARD = "Standard"
    """Standard."""
    PREMIUM = "Premium"
    """Premium."""
    PREMIUM_RS = "PremiumRS"
    """PremiumRS."""


class IntegrationRuntimeState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of integration runtime."""

    INITIAL = "Initial"
    """Initial."""
    STOPPED = "Stopped"
    """Stopped."""
    STARTED = "Started"
    """Started."""
    STARTING = "Starting"
    """Starting."""
    STOPPING = "Stopping"
    """Stopping."""
    NEED_REGISTRATION = "NeedRegistration"
    """NeedRegistration."""
    ONLINE = "Online"
    """Online."""
    LIMITED = "Limited"
    """Limited."""
    OFFLINE = "Offline"
    """Offline."""
    ACCESS_DENIED = "AccessDenied"
    """AccessDenied."""


class IntegrationRuntimeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of integration runtime."""

    MANAGED = "Managed"
    """Managed."""
    SELF_HOSTED = "SelfHosted"
    """SelfHosted."""


class IntegrationRuntimeUpdateResult(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The result of the last integration runtime node update."""

    NONE = "None"
    """None."""
    SUCCEED = "Succeed"
    """Succeed."""
    FAIL = "Fail"
    """Fail."""


class InteractiveCapabilityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The interactive authoring capability status. Must be one of InteractiveCapabilityStatus. The
    default value is 'Enabling'.
    """

    ENABLING = "Enabling"
    """Enabling."""
    ENABLED = "Enabled"
    """Enabled."""
    DISABLING = "Disabling"
    """Disabling."""
    DISABLED = "Disabled"
    """Disabled."""


class LakehouseAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class ManagedIntegrationRuntimeNodeStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The managed integration runtime node status."""

    STARTING = "Starting"
    """Starting."""
    AVAILABLE = "Available"
    """Available."""
    RECYCLING = "Recycling"
    """Recycling."""
    UNAVAILABLE = "Unavailable"
    """Unavailable."""


class ManagedVirtualNetworkReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Managed Virtual Network reference type."""

    MANAGED_VIRTUAL_NETWORK_REFERENCE = "ManagedVirtualNetworkReference"
    """ManagedVirtualNetworkReference."""


class MappingType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the CDC attribute mapping. Note: 'Advanced' mapping type is also saved as 'Derived'."""

    DIRECT = "Direct"
    """Direct."""
    DERIVED = "Derived"
    """Derived."""
    AGGREGATE = "Aggregate"
    """Aggregate."""


class MongoDbAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to be used to connect to the MongoDB database."""

    BASIC = "Basic"
    """Basic."""
    ANONYMOUS = "Anonymous"
    """Anonymous."""


class NetezzaSecurityLevelType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the security level for the driver connection to the data store. PreferredUnSecured :
    prefer unsecured, allow fallback to secured connection if required. OnlyUnSecured : strictly
    unsecured, no fallback.
    """

    PREFERRED_UN_SECURED = "PreferredUnSecured"
    """PreferredUnSecured."""
    ONLY_UN_SECURED = "OnlyUnSecured"
    """OnlyUnSecured."""


class NotebookParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Notebook parameter type."""

    STRING = "string"
    """string."""
    INT = "int"
    """int."""
    FLOAT = "float"
    """float."""
    BOOL = "bool"
    """bool."""


class NotebookReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Synapse notebook reference type."""

    NOTEBOOK_REFERENCE = "NotebookReference"
    """NotebookReference."""


class ODataAadServicePrincipalCredentialType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specify the credential type (key or cert) is used for service principal."""

    SERVICE_PRINCIPAL_KEY = "ServicePrincipalKey"
    """ServicePrincipalKey."""
    SERVICE_PRINCIPAL_CERT = "ServicePrincipalCert"
    """ServicePrincipalCert."""


class ODataAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of authentication used to connect to the OData service."""

    BASIC = "Basic"
    """Basic."""
    ANONYMOUS = "Anonymous"
    """Anonymous."""
    WINDOWS = "Windows"
    """Windows."""
    AAD_SERVICE_PRINCIPAL = "AadServicePrincipal"
    """AadServicePrincipal."""
    MANAGED_SERVICE_IDENTITY = "ManagedServiceIdentity"
    """ManagedServiceIdentity."""


class OracleAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Authentication type for connecting to the Oracle database. Only used for Version 2.0."""

    BASIC = "Basic"
    """Basic."""


class ParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Parameter type."""

    OBJECT = "Object"
    """Object."""
    STRING = "String"
    """String."""
    INT = "Int"
    """Int."""
    FLOAT = "Float"
    """Float."""
    BOOL = "Bool"
    """Bool."""
    ARRAY = "Array"
    """Array."""
    SECURE_STRING = "SecureString"
    """SecureString."""


class PhoenixAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication mechanism used to connect to the Phoenix server."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    USERNAME_AND_PASSWORD = "UsernameAndPassword"
    """UsernameAndPassword."""
    WINDOWS_AZURE_HD_INSIGHT_SERVICE = "WindowsAzureHDInsightService"
    """WindowsAzureHDInsightService."""


class PipelineReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Pipeline reference type."""

    PIPELINE_REFERENCE = "PipelineReference"
    """PipelineReference."""


class PolybaseSettingsRejectType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates whether the RejectValue property is specified as a literal value or a percentage."""

    VALUE = "value"
    """value."""
    PERCENTAGE = "percentage"
    """percentage."""


class PrestoAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication mechanism used to connect to the Presto server."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    LDAP = "LDAP"
    """LDAP."""


class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not public network access is allowed for the data factory."""

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


class RecurrenceFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enumerates possible frequency option for the schedule trigger."""

    NOT_SPECIFIED = "NotSpecified"
    """NotSpecified."""
    MINUTE = "Minute"
    """Minute."""
    HOUR = "Hour"
    """Hour."""
    DAY = "Day"
    """Day."""
    WEEK = "Week"
    """Week."""
    MONTH = "Month"
    """Month."""
    YEAR = "Year"
    """Year."""


class RestServiceAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of authentication used to connect to the REST service."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    BASIC = "Basic"
    """Basic."""
    AAD_SERVICE_PRINCIPAL = "AadServicePrincipal"
    """AadServicePrincipal."""
    MANAGED_SERVICE_IDENTITY = "ManagedServiceIdentity"
    """ManagedServiceIdentity."""
    O_AUTH2_CLIENT_CREDENTIAL = "OAuth2ClientCredential"
    """OAuth2ClientCredential."""


class RunQueryFilterOperand(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Parameter name to be used for filter. The allowed operands to query pipeline runs are
    PipelineName, RunStart, RunEnd and Status; to query activity runs are ActivityName,
    ActivityRunStart, ActivityRunEnd, ActivityType and Status, and to query trigger runs are
    TriggerName, TriggerRunTimestamp and Status.
    """

    PIPELINE_NAME = "PipelineName"
    """PipelineName."""
    STATUS = "Status"
    """Status."""
    RUN_START = "RunStart"
    """RunStart."""
    RUN_END = "RunEnd"
    """RunEnd."""
    ACTIVITY_NAME = "ActivityName"
    """ActivityName."""
    ACTIVITY_RUN_START = "ActivityRunStart"
    """ActivityRunStart."""
    ACTIVITY_RUN_END = "ActivityRunEnd"
    """ActivityRunEnd."""
    ACTIVITY_TYPE = "ActivityType"
    """ActivityType."""
    TRIGGER_NAME = "TriggerName"
    """TriggerName."""
    TRIGGER_RUN_TIMESTAMP = "TriggerRunTimestamp"
    """TriggerRunTimestamp."""
    RUN_GROUP_ID = "RunGroupId"
    """RunGroupId."""
    LATEST_ONLY = "LatestOnly"
    """LatestOnly."""


class RunQueryFilterOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Operator to be used for filter."""

    EQUALS = "Equals"
    """Equals."""
    NOT_EQUALS = "NotEquals"
    """NotEquals."""
    IN = "In"
    """In."""
    NOT_IN = "NotIn"
    """NotIn."""


class RunQueryOrder(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Sorting order of the parameter."""

    ASC = "ASC"
    """ASC."""
    DESC = "DESC"
    """DESC."""


class RunQueryOrderByField(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Parameter name to be used for order by. The allowed parameters to order by for pipeline runs
    are PipelineName, RunStart, RunEnd and Status; for activity runs are ActivityName,
    ActivityRunStart, ActivityRunEnd and Status; for trigger runs are TriggerName,
    TriggerRunTimestamp and Status.
    """

    RUN_START = "RunStart"
    """RunStart."""
    RUN_END = "RunEnd"
    """RunEnd."""
    PIPELINE_NAME = "PipelineName"
    """PipelineName."""
    STATUS = "Status"
    """Status."""
    ACTIVITY_NAME = "ActivityName"
    """ActivityName."""
    ACTIVITY_RUN_START = "ActivityRunStart"
    """ActivityRunStart."""
    ACTIVITY_RUN_END = "ActivityRunEnd"
    """ActivityRunEnd."""
    TRIGGER_NAME = "TriggerName"
    """TriggerName."""
    TRIGGER_RUN_TIMESTAMP = "TriggerRunTimestamp"
    """TriggerRunTimestamp."""


class SalesforceSinkWriteBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The write behavior for the operation. Default is Insert."""

    INSERT = "Insert"
    """Insert."""
    UPSERT = "Upsert"
    """Upsert."""


class SalesforceV2SinkWriteBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The write behavior for the operation. Default is Insert."""

    INSERT = "Insert"
    """Insert."""
    UPSERT = "Upsert"
    """Upsert."""


class SapCloudForCustomerSinkWriteBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The write behavior for the operation. Default is 'Insert'."""

    INSERT = "Insert"
    """Insert."""
    UPDATE = "Update"
    """Update."""


class SapHanaAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to be used to connect to the SAP HANA server."""

    BASIC = "Basic"
    """Basic."""
    WINDOWS = "Windows"
    """Windows."""


class ScriptActivityLogDestination(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The destination of logs. Type: string."""

    ACTIVITY_OUTPUT = "ActivityOutput"
    """ActivityOutput."""
    EXTERNAL_STORE = "ExternalStore"
    """ExternalStore."""


class ScriptActivityParameterDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The direction of the parameter."""

    INPUT = "Input"
    """Input."""
    OUTPUT = "Output"
    """Output."""
    INPUT_OUTPUT = "InputOutput"
    """InputOutput."""


class ScriptActivityParameterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the parameter."""

    BOOLEAN = "Boolean"
    """Boolean."""
    DATE_TIME = "DateTime"
    """DateTime."""
    DATE_TIME_OFFSET = "DateTimeOffset"
    """DateTimeOffset."""
    DECIMAL = "Decimal"
    """Decimal."""
    DOUBLE = "Double"
    """Double."""
    GUID = "Guid"
    """Guid."""
    INT16 = "Int16"
    """Int16."""
    INT32 = "Int32"
    """Int32."""
    INT64 = "Int64"
    """Int64."""
    SINGLE = "Single"
    """Single."""
    STRING = "String"
    """String."""
    TIMESPAN = "Timespan"
    """Timespan."""


class SelfHostedIntegrationRuntimeNodeStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the integration runtime node."""

    NEED_REGISTRATION = "NeedRegistration"
    """NeedRegistration."""
    ONLINE = "Online"
    """Online."""
    LIMITED = "Limited"
    """Limited."""
    OFFLINE = "Offline"
    """Offline."""
    UPGRADING = "Upgrading"
    """Upgrading."""
    INITIALIZING = "Initializing"
    """Initializing."""
    INITIALIZE_FAILED = "InitializeFailed"
    """InitializeFailed."""


class ServiceNowAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    BASIC = "Basic"
    """Basic."""
    O_AUTH2 = "OAuth2"
    """OAuth2."""


class ServiceNowV2AuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    BASIC = "Basic"
    """Basic."""
    O_AUTH2 = "OAuth2"
    """OAuth2."""


class SftpAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to be used to connect to the FTP server."""

    BASIC = "Basic"
    """Basic."""
    SSH_PUBLIC_KEY = "SshPublicKey"
    """SshPublicKey."""
    MULTI_FACTOR = "MultiFactor"
    """MultiFactor."""


class SnowflakeAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    BASIC = "Basic"
    """Basic."""
    KEY_PAIR = "KeyPair"
    """KeyPair."""
    AAD_SERVICE_PRINCIPAL = "AADServicePrincipal"
    """AADServicePrincipal."""


class SparkAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication method used to access the Spark server."""

    ANONYMOUS = "Anonymous"
    """Anonymous."""
    USERNAME = "Username"
    """Username."""
    USERNAME_AND_PASSWORD = "UsernameAndPassword"
    """UsernameAndPassword."""
    WINDOWS_AZURE_HD_INSIGHT_SERVICE = "WindowsAzureHDInsightService"
    """WindowsAzureHDInsightService."""


class SparkConfigurationReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Spark configuration reference type."""

    SPARK_CONFIGURATION_REFERENCE = "SparkConfigurationReference"
    """SparkConfigurationReference."""


class SparkJobReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Synapse spark job reference type."""

    SPARK_JOB_DEFINITION_REFERENCE = "SparkJobDefinitionReference"
    """SparkJobDefinitionReference."""


class SparkServerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of Spark server."""

    SHARK_SERVER = "SharkServer"
    """SharkServer."""
    SHARK_SERVER2 = "SharkServer2"
    """SharkServer2."""
    SPARK_THRIFT_SERVER = "SparkThriftServer"
    """SparkThriftServer."""


class SparkThriftTransportProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The transport protocol to use in the Thrift layer."""

    BINARY = "Binary"
    """Binary."""
    SASL = "SASL"
    """SASL."""
    HTTP = "HTTP "
    """HTTP."""


class SqlAlwaysEncryptedAkvAuthType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Sql always encrypted AKV authentication type. Type: string."""

    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    MANAGED_IDENTITY = "ManagedIdentity"
    """ManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class SqlServerAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type used for authentication. Type: string."""

    SQL = "SQL"
    """SQL."""
    WINDOWS = "Windows"
    """Windows."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class SsisLogLocationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of SSIS log location."""

    FILE = "File"
    """File."""


class SsisObjectMetadataType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of SSIS object metadata."""

    FOLDER = "Folder"
    """Folder."""
    PROJECT = "Project"
    """Project."""
    PACKAGE = "Package"
    """Package."""
    ENVIRONMENT = "Environment"
    """Environment."""


class SsisPackageLocationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of SSIS package location."""

    SSISDB = "SSISDB"
    """SSISDB."""
    FILE = "File"
    """File."""
    INLINE_PACKAGE = "InlinePackage"
    """InlinePackage."""
    PACKAGE_STORE = "PackageStore"
    """PackageStore."""


class SybaseAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """AuthenticationType to be used for connection."""

    BASIC = "Basic"
    """Basic."""
    WINDOWS = "Windows"
    """Windows."""


class TeamDeskAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    BASIC = "Basic"
    """Basic."""
    TOKEN = "Token"
    """Token."""


class TeradataAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """AuthenticationType to be used for connection."""

    BASIC = "Basic"
    """Basic."""
    WINDOWS = "Windows"
    """Windows."""


class TriggerReferenceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Trigger reference type."""

    TRIGGER_REFERENCE = "TriggerReference"
    """TriggerReference."""


class TriggerRunStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Trigger run status."""

    SUCCEEDED = "Succeeded"
    """Succeeded."""
    FAILED = "Failed"
    """Failed."""
    INPROGRESS = "Inprogress"
    """Inprogress."""


class TriggerRuntimeState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enumerates possible state of Triggers."""

    STARTED = "Started"
    """Started."""
    STOPPED = "Stopped"
    """Stopped."""
    DISABLED = "Disabled"
    """Disabled."""


class TumblingWindowFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enumerates possible frequency option for the tumbling window trigger."""

    MINUTE = "Minute"
    """Minute."""
    HOUR = "Hour"
    """Hour."""
    MONTH = "Month"
    """Month."""


class Type(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Linked service reference type."""

    LINKED_SERVICE_REFERENCE = "LinkedServiceReference"
    """LinkedServiceReference."""


class ValueType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of value copied from source."""

    ACTUAL = "actual"
    """actual."""
    DISPLAY = "display"
    """display."""


class VariableType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Variable type."""

    STRING = "String"
    """String."""
    BOOL = "Bool"
    """Bool."""
    ARRAY = "Array"
    """Array."""


class WarehouseAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    SERVICE_PRINCIPAL = "ServicePrincipal"
    """ServicePrincipal."""
    SYSTEM_ASSIGNED_MANAGED_IDENTITY = "SystemAssignedManagedIdentity"
    """SystemAssignedManagedIdentity."""
    USER_ASSIGNED_MANAGED_IDENTITY = "UserAssignedManagedIdentity"
    """UserAssignedManagedIdentity."""


class WebActivityMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The list of HTTP methods supported by a WebActivity."""

    GET = "GET"
    """GET."""
    POST = "POST"
    """POST."""
    PUT = "PUT"
    """PUT."""
    DELETE = "DELETE"
    """DELETE."""


class WebAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of authentication used to connect to the web table source."""

    BASIC = "Basic"
    """Basic."""
    ANONYMOUS = "Anonymous"
    """Anonymous."""
    CLIENT_CERTIFICATE = "ClientCertificate"
    """ClientCertificate."""


class WebHookActivityMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The list of HTTP methods supported by a WebHook activity."""

    POST = "POST"
    """POST."""


class ZendeskAuthenticationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication type to use."""

    BASIC = "Basic"
    """Basic."""
    TOKEN = "Token"
    """Token."""
