// Code generated by smithy-go-codegen DO NOT EDIT.

package types

type AdditionalOptionKeys string

// Enum values for AdditionalOptionKeys
const (
	AdditionalOptionKeysCacheOption AdditionalOptionKeys = "performanceTuning.caching"
)

// Values returns all known values for AdditionalOptionKeys. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (AdditionalOptionKeys) Values() []AdditionalOptionKeys {
	return []AdditionalOptionKeys{
		"performanceTuning.caching",
	}
}

type AggFunction string

// Enum values for AggFunction
const (
	AggFunctionAvg           AggFunction = "avg"
	AggFunctionCountDistinct AggFunction = "countDistinct"
	AggFunctionCount         AggFunction = "count"
	AggFunctionFirst         AggFunction = "first"
	AggFunctionLast          AggFunction = "last"
	AggFunctionKurtosis      AggFunction = "kurtosis"
	AggFunctionMax           AggFunction = "max"
	AggFunctionMin           AggFunction = "min"
	AggFunctionSkewness      AggFunction = "skewness"
	AggFunctionStddevSamp    AggFunction = "stddev_samp"
	AggFunctionStddevPop     AggFunction = "stddev_pop"
	AggFunctionSum           AggFunction = "sum"
	AggFunctionSumDistinct   AggFunction = "sumDistinct"
	AggFunctionVarSamp       AggFunction = "var_samp"
	AggFunctionVarPop        AggFunction = "var_pop"
)

// Values returns all known values for AggFunction. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (AggFunction) Values() []AggFunction {
	return []AggFunction{
		"avg",
		"countDistinct",
		"count",
		"first",
		"last",
		"kurtosis",
		"max",
		"min",
		"skewness",
		"stddev_samp",
		"stddev_pop",
		"sum",
		"sumDistinct",
		"var_samp",
		"var_pop",
	}
}

type BackfillErrorCode string

// Enum values for BackfillErrorCode
const (
	BackfillErrorCodeEncryptedPartitionError            BackfillErrorCode = "ENCRYPTED_PARTITION_ERROR"
	BackfillErrorCodeInternalError                      BackfillErrorCode = "INTERNAL_ERROR"
	BackfillErrorCodeInvalidPartitionTypeDataError      BackfillErrorCode = "INVALID_PARTITION_TYPE_DATA_ERROR"
	BackfillErrorCodeMissingPartitionValueError         BackfillErrorCode = "MISSING_PARTITION_VALUE_ERROR"
	BackfillErrorCodeUnsupportedPartitionCharacterError BackfillErrorCode = "UNSUPPORTED_PARTITION_CHARACTER_ERROR"
)

// Values returns all known values for BackfillErrorCode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (BackfillErrorCode) Values() []BackfillErrorCode {
	return []BackfillErrorCode{
		"ENCRYPTED_PARTITION_ERROR",
		"INTERNAL_ERROR",
		"INVALID_PARTITION_TYPE_DATA_ERROR",
		"MISSING_PARTITION_VALUE_ERROR",
		"UNSUPPORTED_PARTITION_CHARACTER_ERROR",
	}
}

type BlueprintRunState string

// Enum values for BlueprintRunState
const (
	BlueprintRunStateRunning     BlueprintRunState = "RUNNING"
	BlueprintRunStateSucceeded   BlueprintRunState = "SUCCEEDED"
	BlueprintRunStateFailed      BlueprintRunState = "FAILED"
	BlueprintRunStateRollingBack BlueprintRunState = "ROLLING_BACK"
)

// Values returns all known values for BlueprintRunState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (BlueprintRunState) Values() []BlueprintRunState {
	return []BlueprintRunState{
		"RUNNING",
		"SUCCEEDED",
		"FAILED",
		"ROLLING_BACK",
	}
}

type BlueprintStatus string

// Enum values for BlueprintStatus
const (
	BlueprintStatusCreating BlueprintStatus = "CREATING"
	BlueprintStatusActive   BlueprintStatus = "ACTIVE"
	BlueprintStatusUpdating BlueprintStatus = "UPDATING"
	BlueprintStatusFailed   BlueprintStatus = "FAILED"
)

// Values returns all known values for BlueprintStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (BlueprintStatus) Values() []BlueprintStatus {
	return []BlueprintStatus{
		"CREATING",
		"ACTIVE",
		"UPDATING",
		"FAILED",
	}
}

type CatalogEncryptionMode string

// Enum values for CatalogEncryptionMode
const (
	CatalogEncryptionModeDisabled CatalogEncryptionMode = "DISABLED"
	CatalogEncryptionModeSsekms   CatalogEncryptionMode = "SSE-KMS"
)

// Values returns all known values for CatalogEncryptionMode. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CatalogEncryptionMode) Values() []CatalogEncryptionMode {
	return []CatalogEncryptionMode{
		"DISABLED",
		"SSE-KMS",
	}
}

type CloudWatchEncryptionMode string

// Enum values for CloudWatchEncryptionMode
const (
	CloudWatchEncryptionModeDisabled CloudWatchEncryptionMode = "DISABLED"
	CloudWatchEncryptionModeSsekms   CloudWatchEncryptionMode = "SSE-KMS"
)

// Values returns all known values for CloudWatchEncryptionMode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (CloudWatchEncryptionMode) Values() []CloudWatchEncryptionMode {
	return []CloudWatchEncryptionMode{
		"DISABLED",
		"SSE-KMS",
	}
}

type ColumnStatisticsType string

// Enum values for ColumnStatisticsType
const (
	ColumnStatisticsTypeBoolean ColumnStatisticsType = "BOOLEAN"
	ColumnStatisticsTypeDate    ColumnStatisticsType = "DATE"
	ColumnStatisticsTypeDecimal ColumnStatisticsType = "DECIMAL"
	ColumnStatisticsTypeDouble  ColumnStatisticsType = "DOUBLE"
	ColumnStatisticsTypeLong    ColumnStatisticsType = "LONG"
	ColumnStatisticsTypeString  ColumnStatisticsType = "STRING"
	ColumnStatisticsTypeBinary  ColumnStatisticsType = "BINARY"
)

// Values returns all known values for ColumnStatisticsType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ColumnStatisticsType) Values() []ColumnStatisticsType {
	return []ColumnStatisticsType{
		"BOOLEAN",
		"DATE",
		"DECIMAL",
		"DOUBLE",
		"LONG",
		"STRING",
		"BINARY",
	}
}

type Comparator string

// Enum values for Comparator
const (
	ComparatorEquals            Comparator = "EQUALS"
	ComparatorGreaterThan       Comparator = "GREATER_THAN"
	ComparatorLessThan          Comparator = "LESS_THAN"
	ComparatorGreaterThanEquals Comparator = "GREATER_THAN_EQUALS"
	ComparatorLessThanEquals    Comparator = "LESS_THAN_EQUALS"
)

// Values returns all known values for Comparator. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (Comparator) Values() []Comparator {
	return []Comparator{
		"EQUALS",
		"GREATER_THAN",
		"LESS_THAN",
		"GREATER_THAN_EQUALS",
		"LESS_THAN_EQUALS",
	}
}

type Compatibility string

// Enum values for Compatibility
const (
	CompatibilityNone        Compatibility = "NONE"
	CompatibilityDisabled    Compatibility = "DISABLED"
	CompatibilityBackward    Compatibility = "BACKWARD"
	CompatibilityBackwardAll Compatibility = "BACKWARD_ALL"
	CompatibilityForward     Compatibility = "FORWARD"
	CompatibilityForwardAll  Compatibility = "FORWARD_ALL"
	CompatibilityFull        Compatibility = "FULL"
	CompatibilityFullAll     Compatibility = "FULL_ALL"
)

// Values returns all known values for Compatibility. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (Compatibility) Values() []Compatibility {
	return []Compatibility{
		"NONE",
		"DISABLED",
		"BACKWARD",
		"BACKWARD_ALL",
		"FORWARD",
		"FORWARD_ALL",
		"FULL",
		"FULL_ALL",
	}
}

type CompressionType string

// Enum values for CompressionType
const (
	CompressionTypeGzip  CompressionType = "gzip"
	CompressionTypeBzip2 CompressionType = "bzip2"
)

// Values returns all known values for CompressionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CompressionType) Values() []CompressionType {
	return []CompressionType{
		"gzip",
		"bzip2",
	}
}

type ConnectionPropertyKey string

// Enum values for ConnectionPropertyKey
const (
	ConnectionPropertyKeyHost                                 ConnectionPropertyKey = "HOST"
	ConnectionPropertyKeyPort                                 ConnectionPropertyKey = "PORT"
	ConnectionPropertyKeyUserName                             ConnectionPropertyKey = "USERNAME"
	ConnectionPropertyKeyPassword                             ConnectionPropertyKey = "PASSWORD"
	ConnectionPropertyKeyEncryptedPassword                    ConnectionPropertyKey = "ENCRYPTED_PASSWORD"
	ConnectionPropertyKeyJdbcDriverJarUri                     ConnectionPropertyKey = "JDBC_DRIVER_JAR_URI"
	ConnectionPropertyKeyJdbcDriverClassName                  ConnectionPropertyKey = "JDBC_DRIVER_CLASS_NAME"
	ConnectionPropertyKeyJdbcEngine                           ConnectionPropertyKey = "JDBC_ENGINE"
	ConnectionPropertyKeyJdbcEngineVersion                    ConnectionPropertyKey = "JDBC_ENGINE_VERSION"
	ConnectionPropertyKeyConfigFiles                          ConnectionPropertyKey = "CONFIG_FILES"
	ConnectionPropertyKeyInstanceId                           ConnectionPropertyKey = "INSTANCE_ID"
	ConnectionPropertyKeyJdbcConnectionUrl                    ConnectionPropertyKey = "JDBC_CONNECTION_URL"
	ConnectionPropertyKeyJdbcEnforceSsl                       ConnectionPropertyKey = "JDBC_ENFORCE_SSL"
	ConnectionPropertyKeyCustomJdbcCert                       ConnectionPropertyKey = "CUSTOM_JDBC_CERT"
	ConnectionPropertyKeySkipCustomJdbcCertValidation         ConnectionPropertyKey = "SKIP_CUSTOM_JDBC_CERT_VALIDATION"
	ConnectionPropertyKeyCustomJdbcCertString                 ConnectionPropertyKey = "CUSTOM_JDBC_CERT_STRING"
	ConnectionPropertyKeyConnectionUrl                        ConnectionPropertyKey = "CONNECTION_URL"
	ConnectionPropertyKeyKafkaBootstrapServers                ConnectionPropertyKey = "KAFKA_BOOTSTRAP_SERVERS"
	ConnectionPropertyKeyKafkaSslEnabled                      ConnectionPropertyKey = "KAFKA_SSL_ENABLED"
	ConnectionPropertyKeyKafkaCustomCert                      ConnectionPropertyKey = "KAFKA_CUSTOM_CERT"
	ConnectionPropertyKeyKafkaSkipCustomCertValidation        ConnectionPropertyKey = "KAFKA_SKIP_CUSTOM_CERT_VALIDATION"
	ConnectionPropertyKeyKafkaClientKeystore                  ConnectionPropertyKey = "KAFKA_CLIENT_KEYSTORE"
	ConnectionPropertyKeyKafkaClientKeystorePassword          ConnectionPropertyKey = "KAFKA_CLIENT_KEYSTORE_PASSWORD"
	ConnectionPropertyKeyKafkaClientKeyPassword               ConnectionPropertyKey = "KAFKA_CLIENT_KEY_PASSWORD"
	ConnectionPropertyKeyEncryptedKafkaClientKeystorePassword ConnectionPropertyKey = "ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD"
	ConnectionPropertyKeyEncryptedKafkaClientKeyPassword      ConnectionPropertyKey = "ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD"
	ConnectionPropertyKeySecretId                             ConnectionPropertyKey = "SECRET_ID"
	ConnectionPropertyKeyConnectorUrl                         ConnectionPropertyKey = "CONNECTOR_URL"
	ConnectionPropertyKeyConnectorType                        ConnectionPropertyKey = "CONNECTOR_TYPE"
	ConnectionPropertyKeyConnectorClassName                   ConnectionPropertyKey = "CONNECTOR_CLASS_NAME"
)

// Values returns all known values for ConnectionPropertyKey. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ConnectionPropertyKey) Values() []ConnectionPropertyKey {
	return []ConnectionPropertyKey{
		"HOST",
		"PORT",
		"USERNAME",
		"PASSWORD",
		"ENCRYPTED_PASSWORD",
		"JDBC_DRIVER_JAR_URI",
		"JDBC_DRIVER_CLASS_NAME",
		"JDBC_ENGINE",
		"JDBC_ENGINE_VERSION",
		"CONFIG_FILES",
		"INSTANCE_ID",
		"JDBC_CONNECTION_URL",
		"JDBC_ENFORCE_SSL",
		"CUSTOM_JDBC_CERT",
		"SKIP_CUSTOM_JDBC_CERT_VALIDATION",
		"CUSTOM_JDBC_CERT_STRING",
		"CONNECTION_URL",
		"KAFKA_BOOTSTRAP_SERVERS",
		"KAFKA_SSL_ENABLED",
		"KAFKA_CUSTOM_CERT",
		"KAFKA_SKIP_CUSTOM_CERT_VALIDATION",
		"KAFKA_CLIENT_KEYSTORE",
		"KAFKA_CLIENT_KEYSTORE_PASSWORD",
		"KAFKA_CLIENT_KEY_PASSWORD",
		"ENCRYPTED_KAFKA_CLIENT_KEYSTORE_PASSWORD",
		"ENCRYPTED_KAFKA_CLIENT_KEY_PASSWORD",
		"SECRET_ID",
		"CONNECTOR_URL",
		"CONNECTOR_TYPE",
		"CONNECTOR_CLASS_NAME",
	}
}

type ConnectionType string

// Enum values for ConnectionType
const (
	ConnectionTypeJdbc        ConnectionType = "JDBC"
	ConnectionTypeSftp        ConnectionType = "SFTP"
	ConnectionTypeMongodb     ConnectionType = "MONGODB"
	ConnectionTypeKafka       ConnectionType = "KAFKA"
	ConnectionTypeNetwork     ConnectionType = "NETWORK"
	ConnectionTypeMarketplace ConnectionType = "MARKETPLACE"
	ConnectionTypeCustom      ConnectionType = "CUSTOM"
)

// Values returns all known values for ConnectionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ConnectionType) Values() []ConnectionType {
	return []ConnectionType{
		"JDBC",
		"SFTP",
		"MONGODB",
		"KAFKA",
		"NETWORK",
		"MARKETPLACE",
		"CUSTOM",
	}
}

type CrawlerHistoryState string

// Enum values for CrawlerHistoryState
const (
	CrawlerHistoryStateRunning   CrawlerHistoryState = "RUNNING"
	CrawlerHistoryStateCompleted CrawlerHistoryState = "COMPLETED"
	CrawlerHistoryStateFailed    CrawlerHistoryState = "FAILED"
	CrawlerHistoryStateStopped   CrawlerHistoryState = "STOPPED"
)

// Values returns all known values for CrawlerHistoryState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CrawlerHistoryState) Values() []CrawlerHistoryState {
	return []CrawlerHistoryState{
		"RUNNING",
		"COMPLETED",
		"FAILED",
		"STOPPED",
	}
}

type CrawlerLineageSettings string

// Enum values for CrawlerLineageSettings
const (
	CrawlerLineageSettingsEnable  CrawlerLineageSettings = "ENABLE"
	CrawlerLineageSettingsDisable CrawlerLineageSettings = "DISABLE"
)

// Values returns all known values for CrawlerLineageSettings. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CrawlerLineageSettings) Values() []CrawlerLineageSettings {
	return []CrawlerLineageSettings{
		"ENABLE",
		"DISABLE",
	}
}

type CrawlerState string

// Enum values for CrawlerState
const (
	CrawlerStateReady    CrawlerState = "READY"
	CrawlerStateRunning  CrawlerState = "RUNNING"
	CrawlerStateStopping CrawlerState = "STOPPING"
)

// Values returns all known values for CrawlerState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CrawlerState) Values() []CrawlerState {
	return []CrawlerState{
		"READY",
		"RUNNING",
		"STOPPING",
	}
}

type CrawlState string

// Enum values for CrawlState
const (
	CrawlStateRunning    CrawlState = "RUNNING"
	CrawlStateCancelling CrawlState = "CANCELLING"
	CrawlStateCancelled  CrawlState = "CANCELLED"
	CrawlStateSucceeded  CrawlState = "SUCCEEDED"
	CrawlStateFailed     CrawlState = "FAILED"
	CrawlStateError      CrawlState = "ERROR"
)

// Values returns all known values for CrawlState. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (CrawlState) Values() []CrawlState {
	return []CrawlState{
		"RUNNING",
		"CANCELLING",
		"CANCELLED",
		"SUCCEEDED",
		"FAILED",
		"ERROR",
	}
}

type CsvHeaderOption string

// Enum values for CsvHeaderOption
const (
	CsvHeaderOptionUnknown CsvHeaderOption = "UNKNOWN"
	CsvHeaderOptionPresent CsvHeaderOption = "PRESENT"
	CsvHeaderOptionAbsent  CsvHeaderOption = "ABSENT"
)

// Values returns all known values for CsvHeaderOption. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (CsvHeaderOption) Values() []CsvHeaderOption {
	return []CsvHeaderOption{
		"UNKNOWN",
		"PRESENT",
		"ABSENT",
	}
}

type DataFormat string

// Enum values for DataFormat
const (
	DataFormatAvro     DataFormat = "AVRO"
	DataFormatJson     DataFormat = "JSON"
	DataFormatProtobuf DataFormat = "PROTOBUF"
)

// Values returns all known values for DataFormat. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (DataFormat) Values() []DataFormat {
	return []DataFormat{
		"AVRO",
		"JSON",
		"PROTOBUF",
	}
}

type DataQualityRuleResultStatus string

// Enum values for DataQualityRuleResultStatus
const (
	DataQualityRuleResultStatusPass  DataQualityRuleResultStatus = "PASS"
	DataQualityRuleResultStatusFail  DataQualityRuleResultStatus = "FAIL"
	DataQualityRuleResultStatusError DataQualityRuleResultStatus = "ERROR"
)

// Values returns all known values for DataQualityRuleResultStatus. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (DataQualityRuleResultStatus) Values() []DataQualityRuleResultStatus {
	return []DataQualityRuleResultStatus{
		"PASS",
		"FAIL",
		"ERROR",
	}
}

type DeleteBehavior string

// Enum values for DeleteBehavior
const (
	DeleteBehaviorLog                 DeleteBehavior = "LOG"
	DeleteBehaviorDeleteFromDatabase  DeleteBehavior = "DELETE_FROM_DATABASE"
	DeleteBehaviorDeprecateInDatabase DeleteBehavior = "DEPRECATE_IN_DATABASE"
)

// Values returns all known values for DeleteBehavior. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DeleteBehavior) Values() []DeleteBehavior {
	return []DeleteBehavior{
		"LOG",
		"DELETE_FROM_DATABASE",
		"DEPRECATE_IN_DATABASE",
	}
}

type DeltaTargetCompressionType string

// Enum values for DeltaTargetCompressionType
const (
	DeltaTargetCompressionTypeUncompressed DeltaTargetCompressionType = "uncompressed"
	DeltaTargetCompressionTypeSnappy       DeltaTargetCompressionType = "snappy"
)

// Values returns all known values for DeltaTargetCompressionType. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (DeltaTargetCompressionType) Values() []DeltaTargetCompressionType {
	return []DeltaTargetCompressionType{
		"uncompressed",
		"snappy",
	}
}

type DQStopJobOnFailureTiming string

// Enum values for DQStopJobOnFailureTiming
const (
	DQStopJobOnFailureTimingImmediate     DQStopJobOnFailureTiming = "Immediate"
	DQStopJobOnFailureTimingAfterDataLoad DQStopJobOnFailureTiming = "AfterDataLoad"
)

// Values returns all known values for DQStopJobOnFailureTiming. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (DQStopJobOnFailureTiming) Values() []DQStopJobOnFailureTiming {
	return []DQStopJobOnFailureTiming{
		"Immediate",
		"AfterDataLoad",
	}
}

type DQTransformOutput string

// Enum values for DQTransformOutput
const (
	DQTransformOutputPrimaryInput      DQTransformOutput = "PrimaryInput"
	DQTransformOutputEvaluationResults DQTransformOutput = "EvaluationResults"
)

// Values returns all known values for DQTransformOutput. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DQTransformOutput) Values() []DQTransformOutput {
	return []DQTransformOutput{
		"PrimaryInput",
		"EvaluationResults",
	}
}

type EnableHybridValues string

// Enum values for EnableHybridValues
const (
	EnableHybridValuesTrue  EnableHybridValues = "TRUE"
	EnableHybridValuesFalse EnableHybridValues = "FALSE"
)

// Values returns all known values for EnableHybridValues. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (EnableHybridValues) Values() []EnableHybridValues {
	return []EnableHybridValues{
		"TRUE",
		"FALSE",
	}
}

type ExecutionClass string

// Enum values for ExecutionClass
const (
	ExecutionClassFlex     ExecutionClass = "FLEX"
	ExecutionClassStandard ExecutionClass = "STANDARD"
)

// Values returns all known values for ExecutionClass. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ExecutionClass) Values() []ExecutionClass {
	return []ExecutionClass{
		"FLEX",
		"STANDARD",
	}
}

type ExistCondition string

// Enum values for ExistCondition
const (
	ExistConditionMustExist ExistCondition = "MUST_EXIST"
	ExistConditionNotExist  ExistCondition = "NOT_EXIST"
	ExistConditionNone      ExistCondition = "NONE"
)

// Values returns all known values for ExistCondition. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ExistCondition) Values() []ExistCondition {
	return []ExistCondition{
		"MUST_EXIST",
		"NOT_EXIST",
		"NONE",
	}
}

type FederationSourceErrorCode string

// Enum values for FederationSourceErrorCode
const (
	FederationSourceErrorCodeInvalidResponseException       FederationSourceErrorCode = "InvalidResponseException"
	FederationSourceErrorCodeOperationTimeoutException      FederationSourceErrorCode = "OperationTimeoutException"
	FederationSourceErrorCodeOperationNotSupportedException FederationSourceErrorCode = "OperationNotSupportedException"
	FederationSourceErrorCodeInternalServiceException       FederationSourceErrorCode = "InternalServiceException"
	FederationSourceErrorCodeThrottlingException            FederationSourceErrorCode = "ThrottlingException"
)

// Values returns all known values for FederationSourceErrorCode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (FederationSourceErrorCode) Values() []FederationSourceErrorCode {
	return []FederationSourceErrorCode{
		"InvalidResponseException",
		"OperationTimeoutException",
		"OperationNotSupportedException",
		"InternalServiceException",
		"ThrottlingException",
	}
}

type FieldName string

// Enum values for FieldName
const (
	FieldNameCrawlId   FieldName = "CRAWL_ID"
	FieldNameState     FieldName = "STATE"
	FieldNameStartTime FieldName = "START_TIME"
	FieldNameEndTime   FieldName = "END_TIME"
	FieldNameDpuHour   FieldName = "DPU_HOUR"
)

// Values returns all known values for FieldName. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (FieldName) Values() []FieldName {
	return []FieldName{
		"CRAWL_ID",
		"STATE",
		"START_TIME",
		"END_TIME",
		"DPU_HOUR",
	}
}

type FilterLogicalOperator string

// Enum values for FilterLogicalOperator
const (
	FilterLogicalOperatorAnd FilterLogicalOperator = "AND"
	FilterLogicalOperatorOr  FilterLogicalOperator = "OR"
)

// Values returns all known values for FilterLogicalOperator. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FilterLogicalOperator) Values() []FilterLogicalOperator {
	return []FilterLogicalOperator{
		"AND",
		"OR",
	}
}

type FilterOperation string

// Enum values for FilterOperation
const (
	FilterOperationEq     FilterOperation = "EQ"
	FilterOperationLt     FilterOperation = "LT"
	FilterOperationGt     FilterOperation = "GT"
	FilterOperationLte    FilterOperation = "LTE"
	FilterOperationGte    FilterOperation = "GTE"
	FilterOperationRegex  FilterOperation = "REGEX"
	FilterOperationIsnull FilterOperation = "ISNULL"
)

// Values returns all known values for FilterOperation. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FilterOperation) Values() []FilterOperation {
	return []FilterOperation{
		"EQ",
		"LT",
		"GT",
		"LTE",
		"GTE",
		"REGEX",
		"ISNULL",
	}
}

type FilterOperator string

// Enum values for FilterOperator
const (
	FilterOperatorGt FilterOperator = "GT"
	FilterOperatorGe FilterOperator = "GE"
	FilterOperatorLt FilterOperator = "LT"
	FilterOperatorLe FilterOperator = "LE"
	FilterOperatorEq FilterOperator = "EQ"
	FilterOperatorNe FilterOperator = "NE"
)

// Values returns all known values for FilterOperator. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FilterOperator) Values() []FilterOperator {
	return []FilterOperator{
		"GT",
		"GE",
		"LT",
		"LE",
		"EQ",
		"NE",
	}
}

type FilterValueType string

// Enum values for FilterValueType
const (
	FilterValueTypeColumnextracted FilterValueType = "COLUMNEXTRACTED"
	FilterValueTypeConstant        FilterValueType = "CONSTANT"
)

// Values returns all known values for FilterValueType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (FilterValueType) Values() []FilterValueType {
	return []FilterValueType{
		"COLUMNEXTRACTED",
		"CONSTANT",
	}
}

type GlueRecordType string

// Enum values for GlueRecordType
const (
	GlueRecordTypeDate       GlueRecordType = "DATE"
	GlueRecordTypeString     GlueRecordType = "STRING"
	GlueRecordTypeTimestamp  GlueRecordType = "TIMESTAMP"
	GlueRecordTypeInt        GlueRecordType = "INT"
	GlueRecordTypeFloat      GlueRecordType = "FLOAT"
	GlueRecordTypeLong       GlueRecordType = "LONG"
	GlueRecordTypeBigdecimal GlueRecordType = "BIGDECIMAL"
	GlueRecordTypeByte       GlueRecordType = "BYTE"
	GlueRecordTypeShort      GlueRecordType = "SHORT"
	GlueRecordTypeDouble     GlueRecordType = "DOUBLE"
)

// Values returns all known values for GlueRecordType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (GlueRecordType) Values() []GlueRecordType {
	return []GlueRecordType{
		"DATE",
		"STRING",
		"TIMESTAMP",
		"INT",
		"FLOAT",
		"LONG",
		"BIGDECIMAL",
		"BYTE",
		"SHORT",
		"DOUBLE",
	}
}

type HudiTargetCompressionType string

// Enum values for HudiTargetCompressionType
const (
	HudiTargetCompressionTypeGzip         HudiTargetCompressionType = "gzip"
	HudiTargetCompressionTypeLzo          HudiTargetCompressionType = "lzo"
	HudiTargetCompressionTypeUncompressed HudiTargetCompressionType = "uncompressed"
	HudiTargetCompressionTypeSnappy       HudiTargetCompressionType = "snappy"
)

// Values returns all known values for HudiTargetCompressionType. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (HudiTargetCompressionType) Values() []HudiTargetCompressionType {
	return []HudiTargetCompressionType{
		"gzip",
		"lzo",
		"uncompressed",
		"snappy",
	}
}

type JDBCConnectionType string

// Enum values for JDBCConnectionType
const (
	JDBCConnectionTypeSqlserver  JDBCConnectionType = "sqlserver"
	JDBCConnectionTypeMysql      JDBCConnectionType = "mysql"
	JDBCConnectionTypeOracle     JDBCConnectionType = "oracle"
	JDBCConnectionTypePostgresql JDBCConnectionType = "postgresql"
	JDBCConnectionTypeRedshift   JDBCConnectionType = "redshift"
)

// Values returns all known values for JDBCConnectionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (JDBCConnectionType) Values() []JDBCConnectionType {
	return []JDBCConnectionType{
		"sqlserver",
		"mysql",
		"oracle",
		"postgresql",
		"redshift",
	}
}

type JDBCDataType string

// Enum values for JDBCDataType
const (
	JDBCDataTypeArray                 JDBCDataType = "ARRAY"
	JDBCDataTypeBigint                JDBCDataType = "BIGINT"
	JDBCDataTypeBinary                JDBCDataType = "BINARY"
	JDBCDataTypeBit                   JDBCDataType = "BIT"
	JDBCDataTypeBlob                  JDBCDataType = "BLOB"
	JDBCDataTypeBoolean               JDBCDataType = "BOOLEAN"
	JDBCDataTypeChar                  JDBCDataType = "CHAR"
	JDBCDataTypeClob                  JDBCDataType = "CLOB"
	JDBCDataTypeDatalink              JDBCDataType = "DATALINK"
	JDBCDataTypeDate                  JDBCDataType = "DATE"
	JDBCDataTypeDecimal               JDBCDataType = "DECIMAL"
	JDBCDataTypeDistinct              JDBCDataType = "DISTINCT"
	JDBCDataTypeDouble                JDBCDataType = "DOUBLE"
	JDBCDataTypeFloat                 JDBCDataType = "FLOAT"
	JDBCDataTypeInteger               JDBCDataType = "INTEGER"
	JDBCDataTypeJavaObject            JDBCDataType = "JAVA_OBJECT"
	JDBCDataTypeLongnvarchar          JDBCDataType = "LONGNVARCHAR"
	JDBCDataTypeLongvarbinary         JDBCDataType = "LONGVARBINARY"
	JDBCDataTypeLongvarchar           JDBCDataType = "LONGVARCHAR"
	JDBCDataTypeNchar                 JDBCDataType = "NCHAR"
	JDBCDataTypeNclob                 JDBCDataType = "NCLOB"
	JDBCDataTypeNull                  JDBCDataType = "NULL"
	JDBCDataTypeNumeric               JDBCDataType = "NUMERIC"
	JDBCDataTypeNvarchar              JDBCDataType = "NVARCHAR"
	JDBCDataTypeOther                 JDBCDataType = "OTHER"
	JDBCDataTypeReal                  JDBCDataType = "REAL"
	JDBCDataTypeRef                   JDBCDataType = "REF"
	JDBCDataTypeRefCursor             JDBCDataType = "REF_CURSOR"
	JDBCDataTypeRowid                 JDBCDataType = "ROWID"
	JDBCDataTypeSmallint              JDBCDataType = "SMALLINT"
	JDBCDataTypeSqlxml                JDBCDataType = "SQLXML"
	JDBCDataTypeStruct                JDBCDataType = "STRUCT"
	JDBCDataTypeTime                  JDBCDataType = "TIME"
	JDBCDataTypeTimeWithTimezone      JDBCDataType = "TIME_WITH_TIMEZONE"
	JDBCDataTypeTimestamp             JDBCDataType = "TIMESTAMP"
	JDBCDataTypeTimestampWithTimezone JDBCDataType = "TIMESTAMP_WITH_TIMEZONE"
	JDBCDataTypeTinyint               JDBCDataType = "TINYINT"
	JDBCDataTypeVarbinary             JDBCDataType = "VARBINARY"
	JDBCDataTypeVarchar               JDBCDataType = "VARCHAR"
)

// Values returns all known values for JDBCDataType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (JDBCDataType) Values() []JDBCDataType {
	return []JDBCDataType{
		"ARRAY",
		"BIGINT",
		"BINARY",
		"BIT",
		"BLOB",
		"BOOLEAN",
		"CHAR",
		"CLOB",
		"DATALINK",
		"DATE",
		"DECIMAL",
		"DISTINCT",
		"DOUBLE",
		"FLOAT",
		"INTEGER",
		"JAVA_OBJECT",
		"LONGNVARCHAR",
		"LONGVARBINARY",
		"LONGVARCHAR",
		"NCHAR",
		"NCLOB",
		"NULL",
		"NUMERIC",
		"NVARCHAR",
		"OTHER",
		"REAL",
		"REF",
		"REF_CURSOR",
		"ROWID",
		"SMALLINT",
		"SQLXML",
		"STRUCT",
		"TIME",
		"TIME_WITH_TIMEZONE",
		"TIMESTAMP",
		"TIMESTAMP_WITH_TIMEZONE",
		"TINYINT",
		"VARBINARY",
		"VARCHAR",
	}
}

type JdbcMetadataEntry string

// Enum values for JdbcMetadataEntry
const (
	JdbcMetadataEntryComments JdbcMetadataEntry = "COMMENTS"
	JdbcMetadataEntryRawtypes JdbcMetadataEntry = "RAWTYPES"
)

// Values returns all known values for JdbcMetadataEntry. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (JdbcMetadataEntry) Values() []JdbcMetadataEntry {
	return []JdbcMetadataEntry{
		"COMMENTS",
		"RAWTYPES",
	}
}

type JobBookmarksEncryptionMode string

// Enum values for JobBookmarksEncryptionMode
const (
	JobBookmarksEncryptionModeDisabled JobBookmarksEncryptionMode = "DISABLED"
	JobBookmarksEncryptionModeCsekms   JobBookmarksEncryptionMode = "CSE-KMS"
)

// Values returns all known values for JobBookmarksEncryptionMode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (JobBookmarksEncryptionMode) Values() []JobBookmarksEncryptionMode {
	return []JobBookmarksEncryptionMode{
		"DISABLED",
		"CSE-KMS",
	}
}

type JobRunState string

// Enum values for JobRunState
const (
	JobRunStateStarting  JobRunState = "STARTING"
	JobRunStateRunning   JobRunState = "RUNNING"
	JobRunStateStopping  JobRunState = "STOPPING"
	JobRunStateStopped   JobRunState = "STOPPED"
	JobRunStateSucceeded JobRunState = "SUCCEEDED"
	JobRunStateFailed    JobRunState = "FAILED"
	JobRunStateTimeout   JobRunState = "TIMEOUT"
	JobRunStateError     JobRunState = "ERROR"
	JobRunStateWaiting   JobRunState = "WAITING"
)

// Values returns all known values for JobRunState. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (JobRunState) Values() []JobRunState {
	return []JobRunState{
		"STARTING",
		"RUNNING",
		"STOPPING",
		"STOPPED",
		"SUCCEEDED",
		"FAILED",
		"TIMEOUT",
		"ERROR",
		"WAITING",
	}
}

type JoinType string

// Enum values for JoinType
const (
	JoinTypeEquijoin JoinType = "equijoin"
	JoinTypeLeft     JoinType = "left"
	JoinTypeRight    JoinType = "right"
	JoinTypeOuter    JoinType = "outer"
	JoinTypeLeftSemi JoinType = "leftsemi"
	JoinTypeLeftAnti JoinType = "leftanti"
)

// Values returns all known values for JoinType. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (JoinType) Values() []JoinType {
	return []JoinType{
		"equijoin",
		"left",
		"right",
		"outer",
		"leftsemi",
		"leftanti",
	}
}

type Language string

// Enum values for Language
const (
	LanguagePython Language = "PYTHON"
	LanguageScala  Language = "SCALA"
)

// Values returns all known values for Language. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (Language) Values() []Language {
	return []Language{
		"PYTHON",
		"SCALA",
	}
}

type LastCrawlStatus string

// Enum values for LastCrawlStatus
const (
	LastCrawlStatusSucceeded LastCrawlStatus = "SUCCEEDED"
	LastCrawlStatusCancelled LastCrawlStatus = "CANCELLED"
	LastCrawlStatusFailed    LastCrawlStatus = "FAILED"
)

// Values returns all known values for LastCrawlStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (LastCrawlStatus) Values() []LastCrawlStatus {
	return []LastCrawlStatus{
		"SUCCEEDED",
		"CANCELLED",
		"FAILED",
	}
}

type Logical string

// Enum values for Logical
const (
	LogicalAnd Logical = "AND"
	LogicalAny Logical = "ANY"
)

// Values returns all known values for Logical. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (Logical) Values() []Logical {
	return []Logical{
		"AND",
		"ANY",
	}
}

type LogicalOperator string

// Enum values for LogicalOperator
const (
	LogicalOperatorEquals LogicalOperator = "EQUALS"
)

// Values returns all known values for LogicalOperator. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (LogicalOperator) Values() []LogicalOperator {
	return []LogicalOperator{
		"EQUALS",
	}
}

type MetadataOperation string

// Enum values for MetadataOperation
const (
	MetadataOperationCreate MetadataOperation = "CREATE"
)

// Values returns all known values for MetadataOperation. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (MetadataOperation) Values() []MetadataOperation {
	return []MetadataOperation{
		"CREATE",
	}
}

type MLUserDataEncryptionModeString string

// Enum values for MLUserDataEncryptionModeString
const (
	MLUserDataEncryptionModeStringDisabled MLUserDataEncryptionModeString = "DISABLED"
	MLUserDataEncryptionModeStringSsekms   MLUserDataEncryptionModeString = "SSE-KMS"
)

// Values returns all known values for MLUserDataEncryptionModeString. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client. The ordering of this slice is not guaranteed to be stable across
// updates.
func (MLUserDataEncryptionModeString) Values() []MLUserDataEncryptionModeString {
	return []MLUserDataEncryptionModeString{
		"DISABLED",
		"SSE-KMS",
	}
}

type NodeType string

// Enum values for NodeType
const (
	NodeTypeCrawler NodeType = "CRAWLER"
	NodeTypeJob     NodeType = "JOB"
	NodeTypeTrigger NodeType = "TRIGGER"
)

// Values returns all known values for NodeType. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (NodeType) Values() []NodeType {
	return []NodeType{
		"CRAWLER",
		"JOB",
		"TRIGGER",
	}
}

type ParamType string

// Enum values for ParamType
const (
	ParamTypeStr     ParamType = "str"
	ParamTypeInt     ParamType = "int"
	ParamTypeFloat   ParamType = "float"
	ParamTypeComplex ParamType = "complex"
	ParamTypeBool    ParamType = "bool"
	ParamTypeList    ParamType = "list"
	ParamTypeNull    ParamType = "null"
)

// Values returns all known values for ParamType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (ParamType) Values() []ParamType {
	return []ParamType{
		"str",
		"int",
		"float",
		"complex",
		"bool",
		"list",
		"null",
	}
}

type ParquetCompressionType string

// Enum values for ParquetCompressionType
const (
	ParquetCompressionTypeSnappy       ParquetCompressionType = "snappy"
	ParquetCompressionTypeLzo          ParquetCompressionType = "lzo"
	ParquetCompressionTypeGzip         ParquetCompressionType = "gzip"
	ParquetCompressionTypeUncompressed ParquetCompressionType = "uncompressed"
	ParquetCompressionTypeNone         ParquetCompressionType = "none"
)

// Values returns all known values for ParquetCompressionType. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ParquetCompressionType) Values() []ParquetCompressionType {
	return []ParquetCompressionType{
		"snappy",
		"lzo",
		"gzip",
		"uncompressed",
		"none",
	}
}

type PartitionIndexStatus string

// Enum values for PartitionIndexStatus
const (
	PartitionIndexStatusCreating PartitionIndexStatus = "CREATING"
	PartitionIndexStatusActive   PartitionIndexStatus = "ACTIVE"
	PartitionIndexStatusDeleting PartitionIndexStatus = "DELETING"
	PartitionIndexStatusFailed   PartitionIndexStatus = "FAILED"
)

// Values returns all known values for PartitionIndexStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PartitionIndexStatus) Values() []PartitionIndexStatus {
	return []PartitionIndexStatus{
		"CREATING",
		"ACTIVE",
		"DELETING",
		"FAILED",
	}
}

type Permission string

// Enum values for Permission
const (
	PermissionAll                Permission = "ALL"
	PermissionSelect             Permission = "SELECT"
	PermissionAlter              Permission = "ALTER"
	PermissionDrop               Permission = "DROP"
	PermissionDelete             Permission = "DELETE"
	PermissionInsert             Permission = "INSERT"
	PermissionCreateDatabase     Permission = "CREATE_DATABASE"
	PermissionCreateTable        Permission = "CREATE_TABLE"
	PermissionDataLocationAccess Permission = "DATA_LOCATION_ACCESS"
)

// Values returns all known values for Permission. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (Permission) Values() []Permission {
	return []Permission{
		"ALL",
		"SELECT",
		"ALTER",
		"DROP",
		"DELETE",
		"INSERT",
		"CREATE_DATABASE",
		"CREATE_TABLE",
		"DATA_LOCATION_ACCESS",
	}
}

type PermissionType string

// Enum values for PermissionType
const (
	PermissionTypeColumnPermission     PermissionType = "COLUMN_PERMISSION"
	PermissionTypeCellFilterPermission PermissionType = "CELL_FILTER_PERMISSION"
	PermissionTypeNestedPermission     PermissionType = "NESTED_PERMISSION"
	PermissionTypeNestedCellPermission PermissionType = "NESTED_CELL_PERMISSION"
)

// Values returns all known values for PermissionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PermissionType) Values() []PermissionType {
	return []PermissionType{
		"COLUMN_PERMISSION",
		"CELL_FILTER_PERMISSION",
		"NESTED_PERMISSION",
		"NESTED_CELL_PERMISSION",
	}
}

type PiiType string

// Enum values for PiiType
const (
	PiiTypeRowAudit      PiiType = "RowAudit"
	PiiTypeRowMasking    PiiType = "RowMasking"
	PiiTypeColumnAudit   PiiType = "ColumnAudit"
	PiiTypeColumnMasking PiiType = "ColumnMasking"
)

// Values returns all known values for PiiType. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (PiiType) Values() []PiiType {
	return []PiiType{
		"RowAudit",
		"RowMasking",
		"ColumnAudit",
		"ColumnMasking",
	}
}

type PrincipalType string

// Enum values for PrincipalType
const (
	PrincipalTypeUser  PrincipalType = "USER"
	PrincipalTypeRole  PrincipalType = "ROLE"
	PrincipalTypeGroup PrincipalType = "GROUP"
)

// Values returns all known values for PrincipalType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (PrincipalType) Values() []PrincipalType {
	return []PrincipalType{
		"USER",
		"ROLE",
		"GROUP",
	}
}

type QuoteChar string

// Enum values for QuoteChar
const (
	QuoteCharQuote       QuoteChar = "quote"
	QuoteCharQuillemet   QuoteChar = "quillemet"
	QuoteCharSingleQuote QuoteChar = "single_quote"
	QuoteCharDisabled    QuoteChar = "disabled"
)

// Values returns all known values for QuoteChar. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (QuoteChar) Values() []QuoteChar {
	return []QuoteChar{
		"quote",
		"quillemet",
		"single_quote",
		"disabled",
	}
}

type RecrawlBehavior string

// Enum values for RecrawlBehavior
const (
	RecrawlBehaviorCrawlEverything     RecrawlBehavior = "CRAWL_EVERYTHING"
	RecrawlBehaviorCrawlNewFoldersOnly RecrawlBehavior = "CRAWL_NEW_FOLDERS_ONLY"
	RecrawlBehaviorCrawlEventMode      RecrawlBehavior = "CRAWL_EVENT_MODE"
)

// Values returns all known values for RecrawlBehavior. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (RecrawlBehavior) Values() []RecrawlBehavior {
	return []RecrawlBehavior{
		"CRAWL_EVERYTHING",
		"CRAWL_NEW_FOLDERS_ONLY",
		"CRAWL_EVENT_MODE",
	}
}

type RegistryStatus string

// Enum values for RegistryStatus
const (
	RegistryStatusAvailable RegistryStatus = "AVAILABLE"
	RegistryStatusDeleting  RegistryStatus = "DELETING"
)

// Values returns all known values for RegistryStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (RegistryStatus) Values() []RegistryStatus {
	return []RegistryStatus{
		"AVAILABLE",
		"DELETING",
	}
}

type ResourceShareType string

// Enum values for ResourceShareType
const (
	ResourceShareTypeForeign   ResourceShareType = "FOREIGN"
	ResourceShareTypeAll       ResourceShareType = "ALL"
	ResourceShareTypeFederated ResourceShareType = "FEDERATED"
)

// Values returns all known values for ResourceShareType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ResourceShareType) Values() []ResourceShareType {
	return []ResourceShareType{
		"FOREIGN",
		"ALL",
		"FEDERATED",
	}
}

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeJar     ResourceType = "JAR"
	ResourceTypeFile    ResourceType = "FILE"
	ResourceTypeArchive ResourceType = "ARCHIVE"
)

// Values returns all known values for ResourceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ResourceType) Values() []ResourceType {
	return []ResourceType{
		"JAR",
		"FILE",
		"ARCHIVE",
	}
}

type S3EncryptionMode string

// Enum values for S3EncryptionMode
const (
	S3EncryptionModeDisabled S3EncryptionMode = "DISABLED"
	S3EncryptionModeSsekms   S3EncryptionMode = "SSE-KMS"
	S3EncryptionModeSses3    S3EncryptionMode = "SSE-S3"
)

// Values returns all known values for S3EncryptionMode. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (S3EncryptionMode) Values() []S3EncryptionMode {
	return []S3EncryptionMode{
		"DISABLED",
		"SSE-KMS",
		"SSE-S3",
	}
}

type ScheduleState string

// Enum values for ScheduleState
const (
	ScheduleStateScheduled     ScheduleState = "SCHEDULED"
	ScheduleStateNotScheduled  ScheduleState = "NOT_SCHEDULED"
	ScheduleStateTransitioning ScheduleState = "TRANSITIONING"
)

// Values returns all known values for ScheduleState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ScheduleState) Values() []ScheduleState {
	return []ScheduleState{
		"SCHEDULED",
		"NOT_SCHEDULED",
		"TRANSITIONING",
	}
}

type SchemaDiffType string

// Enum values for SchemaDiffType
const (
	SchemaDiffTypeSyntaxDiff SchemaDiffType = "SYNTAX_DIFF"
)

// Values returns all known values for SchemaDiffType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SchemaDiffType) Values() []SchemaDiffType {
	return []SchemaDiffType{
		"SYNTAX_DIFF",
	}
}

type SchemaStatus string

// Enum values for SchemaStatus
const (
	SchemaStatusAvailable SchemaStatus = "AVAILABLE"
	SchemaStatusPending   SchemaStatus = "PENDING"
	SchemaStatusDeleting  SchemaStatus = "DELETING"
)

// Values returns all known values for SchemaStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SchemaStatus) Values() []SchemaStatus {
	return []SchemaStatus{
		"AVAILABLE",
		"PENDING",
		"DELETING",
	}
}

type SchemaVersionStatus string

// Enum values for SchemaVersionStatus
const (
	SchemaVersionStatusAvailable SchemaVersionStatus = "AVAILABLE"
	SchemaVersionStatusPending   SchemaVersionStatus = "PENDING"
	SchemaVersionStatusFailure   SchemaVersionStatus = "FAILURE"
	SchemaVersionStatusDeleting  SchemaVersionStatus = "DELETING"
)

// Values returns all known values for SchemaVersionStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SchemaVersionStatus) Values() []SchemaVersionStatus {
	return []SchemaVersionStatus{
		"AVAILABLE",
		"PENDING",
		"FAILURE",
		"DELETING",
	}
}

type Separator string

// Enum values for Separator
const (
	SeparatorComma     Separator = "comma"
	SeparatorCtrla     Separator = "ctrla"
	SeparatorPipe      Separator = "pipe"
	SeparatorSemicolon Separator = "semicolon"
	SeparatorTab       Separator = "tab"
)

// Values returns all known values for Separator. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (Separator) Values() []Separator {
	return []Separator{
		"comma",
		"ctrla",
		"pipe",
		"semicolon",
		"tab",
	}
}

type SessionStatus string

// Enum values for SessionStatus
const (
	SessionStatusProvisioning SessionStatus = "PROVISIONING"
	SessionStatusReady        SessionStatus = "READY"
	SessionStatusFailed       SessionStatus = "FAILED"
	SessionStatusTimeout      SessionStatus = "TIMEOUT"
	SessionStatusStopping     SessionStatus = "STOPPING"
	SessionStatusStopped      SessionStatus = "STOPPED"
)

// Values returns all known values for SessionStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SessionStatus) Values() []SessionStatus {
	return []SessionStatus{
		"PROVISIONING",
		"READY",
		"FAILED",
		"TIMEOUT",
		"STOPPING",
		"STOPPED",
	}
}

type Sort string

// Enum values for Sort
const (
	SortAscending  Sort = "ASC"
	SortDescending Sort = "DESC"
)

// Values returns all known values for Sort. Note that this can be expanded in the
// future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (Sort) Values() []Sort {
	return []Sort{
		"ASC",
		"DESC",
	}
}

type SortDirectionType string

// Enum values for SortDirectionType
const (
	SortDirectionTypeDescending SortDirectionType = "DESCENDING"
	SortDirectionTypeAscending  SortDirectionType = "ASCENDING"
)

// Values returns all known values for SortDirectionType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SortDirectionType) Values() []SortDirectionType {
	return []SortDirectionType{
		"DESCENDING",
		"ASCENDING",
	}
}

type SourceControlAuthStrategy string

// Enum values for SourceControlAuthStrategy
const (
	SourceControlAuthStrategyPersonalAccessToken SourceControlAuthStrategy = "PERSONAL_ACCESS_TOKEN"
	SourceControlAuthStrategyAwsSecretsManager   SourceControlAuthStrategy = "AWS_SECRETS_MANAGER"
)

// Values returns all known values for SourceControlAuthStrategy. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (SourceControlAuthStrategy) Values() []SourceControlAuthStrategy {
	return []SourceControlAuthStrategy{
		"PERSONAL_ACCESS_TOKEN",
		"AWS_SECRETS_MANAGER",
	}
}

type SourceControlProvider string

// Enum values for SourceControlProvider
const (
	SourceControlProviderGithub        SourceControlProvider = "GITHUB"
	SourceControlProviderAwsCodeCommit SourceControlProvider = "AWS_CODE_COMMIT"
)

// Values returns all known values for SourceControlProvider. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (SourceControlProvider) Values() []SourceControlProvider {
	return []SourceControlProvider{
		"GITHUB",
		"AWS_CODE_COMMIT",
	}
}

type StartingPosition string

// Enum values for StartingPosition
const (
	StartingPositionLatest      StartingPosition = "latest"
	StartingPositionTrimHorizon StartingPosition = "trim_horizon"
	StartingPositionEarliest    StartingPosition = "earliest"
	StartingPositionTimestamp   StartingPosition = "timestamp"
)

// Values returns all known values for StartingPosition. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (StartingPosition) Values() []StartingPosition {
	return []StartingPosition{
		"latest",
		"trim_horizon",
		"earliest",
		"timestamp",
	}
}

type StatementState string

// Enum values for StatementState
const (
	StatementStateWaiting    StatementState = "WAITING"
	StatementStateRunning    StatementState = "RUNNING"
	StatementStateAvailable  StatementState = "AVAILABLE"
	StatementStateCancelling StatementState = "CANCELLING"
	StatementStateCancelled  StatementState = "CANCELLED"
	StatementStateError      StatementState = "ERROR"
)

// Values returns all known values for StatementState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (StatementState) Values() []StatementState {
	return []StatementState{
		"WAITING",
		"RUNNING",
		"AVAILABLE",
		"CANCELLING",
		"CANCELLED",
		"ERROR",
	}
}

type TargetFormat string

// Enum values for TargetFormat
const (
	TargetFormatJson    TargetFormat = "json"
	TargetFormatCsv     TargetFormat = "csv"
	TargetFormatAvro    TargetFormat = "avro"
	TargetFormatOrc     TargetFormat = "orc"
	TargetFormatParquet TargetFormat = "parquet"
	TargetFormatHudi    TargetFormat = "hudi"
	TargetFormatDelta   TargetFormat = "delta"
)

// Values returns all known values for TargetFormat. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TargetFormat) Values() []TargetFormat {
	return []TargetFormat{
		"json",
		"csv",
		"avro",
		"orc",
		"parquet",
		"hudi",
		"delta",
	}
}

type TaskRunSortColumnType string

// Enum values for TaskRunSortColumnType
const (
	TaskRunSortColumnTypeTaskRunType TaskRunSortColumnType = "TASK_RUN_TYPE"
	TaskRunSortColumnTypeStatus      TaskRunSortColumnType = "STATUS"
	TaskRunSortColumnTypeStarted     TaskRunSortColumnType = "STARTED"
)

// Values returns all known values for TaskRunSortColumnType. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TaskRunSortColumnType) Values() []TaskRunSortColumnType {
	return []TaskRunSortColumnType{
		"TASK_RUN_TYPE",
		"STATUS",
		"STARTED",
	}
}

type TaskStatusType string

// Enum values for TaskStatusType
const (
	TaskStatusTypeStarting  TaskStatusType = "STARTING"
	TaskStatusTypeRunning   TaskStatusType = "RUNNING"
	TaskStatusTypeStopping  TaskStatusType = "STOPPING"
	TaskStatusTypeStopped   TaskStatusType = "STOPPED"
	TaskStatusTypeSucceeded TaskStatusType = "SUCCEEDED"
	TaskStatusTypeFailed    TaskStatusType = "FAILED"
	TaskStatusTypeTimeout   TaskStatusType = "TIMEOUT"
)

// Values returns all known values for TaskStatusType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TaskStatusType) Values() []TaskStatusType {
	return []TaskStatusType{
		"STARTING",
		"RUNNING",
		"STOPPING",
		"STOPPED",
		"SUCCEEDED",
		"FAILED",
		"TIMEOUT",
	}
}

type TaskType string

// Enum values for TaskType
const (
	TaskTypeEvaluation            TaskType = "EVALUATION"
	TaskTypeLabelingSetGeneration TaskType = "LABELING_SET_GENERATION"
	TaskTypeImportLabels          TaskType = "IMPORT_LABELS"
	TaskTypeExportLabels          TaskType = "EXPORT_LABELS"
	TaskTypeFindMatches           TaskType = "FIND_MATCHES"
)

// Values returns all known values for TaskType. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (TaskType) Values() []TaskType {
	return []TaskType{
		"EVALUATION",
		"LABELING_SET_GENERATION",
		"IMPORT_LABELS",
		"EXPORT_LABELS",
		"FIND_MATCHES",
	}
}

type TransformSortColumnType string

// Enum values for TransformSortColumnType
const (
	TransformSortColumnTypeName          TransformSortColumnType = "NAME"
	TransformSortColumnTypeTransformType TransformSortColumnType = "TRANSFORM_TYPE"
	TransformSortColumnTypeStatus        TransformSortColumnType = "STATUS"
	TransformSortColumnTypeCreated       TransformSortColumnType = "CREATED"
	TransformSortColumnTypeLastModified  TransformSortColumnType = "LAST_MODIFIED"
)

// Values returns all known values for TransformSortColumnType. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransformSortColumnType) Values() []TransformSortColumnType {
	return []TransformSortColumnType{
		"NAME",
		"TRANSFORM_TYPE",
		"STATUS",
		"CREATED",
		"LAST_MODIFIED",
	}
}

type TransformStatusType string

// Enum values for TransformStatusType
const (
	TransformStatusTypeNotReady TransformStatusType = "NOT_READY"
	TransformStatusTypeReady    TransformStatusType = "READY"
	TransformStatusTypeDeleting TransformStatusType = "DELETING"
)

// Values returns all known values for TransformStatusType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransformStatusType) Values() []TransformStatusType {
	return []TransformStatusType{
		"NOT_READY",
		"READY",
		"DELETING",
	}
}

type TransformType string

// Enum values for TransformType
const (
	TransformTypeFindMatches TransformType = "FIND_MATCHES"
)

// Values returns all known values for TransformType. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TransformType) Values() []TransformType {
	return []TransformType{
		"FIND_MATCHES",
	}
}

type TriggerState string

// Enum values for TriggerState
const (
	TriggerStateCreating     TriggerState = "CREATING"
	TriggerStateCreated      TriggerState = "CREATED"
	TriggerStateActivating   TriggerState = "ACTIVATING"
	TriggerStateActivated    TriggerState = "ACTIVATED"
	TriggerStateDeactivating TriggerState = "DEACTIVATING"
	TriggerStateDeactivated  TriggerState = "DEACTIVATED"
	TriggerStateDeleting     TriggerState = "DELETING"
	TriggerStateUpdating     TriggerState = "UPDATING"
)

// Values returns all known values for TriggerState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TriggerState) Values() []TriggerState {
	return []TriggerState{
		"CREATING",
		"CREATED",
		"ACTIVATING",
		"ACTIVATED",
		"DEACTIVATING",
		"DEACTIVATED",
		"DELETING",
		"UPDATING",
	}
}

type TriggerType string

// Enum values for TriggerType
const (
	TriggerTypeScheduled   TriggerType = "SCHEDULED"
	TriggerTypeConditional TriggerType = "CONDITIONAL"
	TriggerTypeOnDemand    TriggerType = "ON_DEMAND"
	TriggerTypeEvent       TriggerType = "EVENT"
)

// Values returns all known values for TriggerType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (TriggerType) Values() []TriggerType {
	return []TriggerType{
		"SCHEDULED",
		"CONDITIONAL",
		"ON_DEMAND",
		"EVENT",
	}
}

type UnionType string

// Enum values for UnionType
const (
	UnionTypeAll      UnionType = "ALL"
	UnionTypeDistinct UnionType = "DISTINCT"
)

// Values returns all known values for UnionType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (UnionType) Values() []UnionType {
	return []UnionType{
		"ALL",
		"DISTINCT",
	}
}

type UpdateBehavior string

// Enum values for UpdateBehavior
const (
	UpdateBehaviorLog              UpdateBehavior = "LOG"
	UpdateBehaviorUpdateInDatabase UpdateBehavior = "UPDATE_IN_DATABASE"
)

// Values returns all known values for UpdateBehavior. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (UpdateBehavior) Values() []UpdateBehavior {
	return []UpdateBehavior{
		"LOG",
		"UPDATE_IN_DATABASE",
	}
}

type UpdateCatalogBehavior string

// Enum values for UpdateCatalogBehavior
const (
	UpdateCatalogBehaviorUpdateInDatabase UpdateCatalogBehavior = "UPDATE_IN_DATABASE"
	UpdateCatalogBehaviorLog              UpdateCatalogBehavior = "LOG"
)

// Values returns all known values for UpdateCatalogBehavior. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (UpdateCatalogBehavior) Values() []UpdateCatalogBehavior {
	return []UpdateCatalogBehavior{
		"UPDATE_IN_DATABASE",
		"LOG",
	}
}

type WorkerType string

// Enum values for WorkerType
const (
	WorkerTypeStandard WorkerType = "Standard"
	WorkerTypeG1x      WorkerType = "G.1X"
	WorkerTypeG2x      WorkerType = "G.2X"
	WorkerTypeG025x    WorkerType = "G.025X"
	WorkerTypeG4x      WorkerType = "G.4X"
	WorkerTypeG8x      WorkerType = "G.8X"
	WorkerTypeZ2x      WorkerType = "Z.2X"
)

// Values returns all known values for WorkerType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (WorkerType) Values() []WorkerType {
	return []WorkerType{
		"Standard",
		"G.1X",
		"G.2X",
		"G.025X",
		"G.4X",
		"G.8X",
		"Z.2X",
	}
}

type WorkflowRunStatus string

// Enum values for WorkflowRunStatus
const (
	WorkflowRunStatusRunning   WorkflowRunStatus = "RUNNING"
	WorkflowRunStatusCompleted WorkflowRunStatus = "COMPLETED"
	WorkflowRunStatusStopping  WorkflowRunStatus = "STOPPING"
	WorkflowRunStatusStopped   WorkflowRunStatus = "STOPPED"
	WorkflowRunStatusError     WorkflowRunStatus = "ERROR"
)

// Values returns all known values for WorkflowRunStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (WorkflowRunStatus) Values() []WorkflowRunStatus {
	return []WorkflowRunStatus{
		"RUNNING",
		"COMPLETED",
		"STOPPING",
		"STOPPED",
		"ERROR",
	}
}