// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package sagemaker

type AlgorithmSortBy string

// Enum values for AlgorithmSortBy
const (
	AlgorithmSortByName         AlgorithmSortBy = "Name"
	AlgorithmSortByCreationTime AlgorithmSortBy = "CreationTime"
)

func (enum AlgorithmSortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AlgorithmSortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AlgorithmStatus string

// Enum values for AlgorithmStatus
const (
	AlgorithmStatusPending    AlgorithmStatus = "Pending"
	AlgorithmStatusInProgress AlgorithmStatus = "InProgress"
	AlgorithmStatusCompleted  AlgorithmStatus = "Completed"
	AlgorithmStatusFailed     AlgorithmStatus = "Failed"
	AlgorithmStatusDeleting   AlgorithmStatus = "Deleting"
)

func (enum AlgorithmStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AlgorithmStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AppInstanceType string

// Enum values for AppInstanceType
const (
	AppInstanceTypeSystem         AppInstanceType = "system"
	AppInstanceTypeMlT3Micro      AppInstanceType = "ml.t3.micro"
	AppInstanceTypeMlT3Small      AppInstanceType = "ml.t3.small"
	AppInstanceTypeMlT3Medium     AppInstanceType = "ml.t3.medium"
	AppInstanceTypeMlT3Large      AppInstanceType = "ml.t3.large"
	AppInstanceTypeMlT3Xlarge     AppInstanceType = "ml.t3.xlarge"
	AppInstanceTypeMlT32xlarge    AppInstanceType = "ml.t3.2xlarge"
	AppInstanceTypeMlM5Large      AppInstanceType = "ml.m5.large"
	AppInstanceTypeMlM5Xlarge     AppInstanceType = "ml.m5.xlarge"
	AppInstanceTypeMlM52xlarge    AppInstanceType = "ml.m5.2xlarge"
	AppInstanceTypeMlM54xlarge    AppInstanceType = "ml.m5.4xlarge"
	AppInstanceTypeMlM58xlarge    AppInstanceType = "ml.m5.8xlarge"
	AppInstanceTypeMlM512xlarge   AppInstanceType = "ml.m5.12xlarge"
	AppInstanceTypeMlM516xlarge   AppInstanceType = "ml.m5.16xlarge"
	AppInstanceTypeMlM524xlarge   AppInstanceType = "ml.m5.24xlarge"
	AppInstanceTypeMlC5Large      AppInstanceType = "ml.c5.large"
	AppInstanceTypeMlC5Xlarge     AppInstanceType = "ml.c5.xlarge"
	AppInstanceTypeMlC52xlarge    AppInstanceType = "ml.c5.2xlarge"
	AppInstanceTypeMlC54xlarge    AppInstanceType = "ml.c5.4xlarge"
	AppInstanceTypeMlC59xlarge    AppInstanceType = "ml.c5.9xlarge"
	AppInstanceTypeMlC512xlarge   AppInstanceType = "ml.c5.12xlarge"
	AppInstanceTypeMlC518xlarge   AppInstanceType = "ml.c5.18xlarge"
	AppInstanceTypeMlC524xlarge   AppInstanceType = "ml.c5.24xlarge"
	AppInstanceTypeMlP32xlarge    AppInstanceType = "ml.p3.2xlarge"
	AppInstanceTypeMlP38xlarge    AppInstanceType = "ml.p3.8xlarge"
	AppInstanceTypeMlP316xlarge   AppInstanceType = "ml.p3.16xlarge"
	AppInstanceTypeMlG4dnXlarge   AppInstanceType = "ml.g4dn.xlarge"
	AppInstanceTypeMlG4dn2xlarge  AppInstanceType = "ml.g4dn.2xlarge"
	AppInstanceTypeMlG4dn4xlarge  AppInstanceType = "ml.g4dn.4xlarge"
	AppInstanceTypeMlG4dn8xlarge  AppInstanceType = "ml.g4dn.8xlarge"
	AppInstanceTypeMlG4dn12xlarge AppInstanceType = "ml.g4dn.12xlarge"
	AppInstanceTypeMlG4dn16xlarge AppInstanceType = "ml.g4dn.16xlarge"
)

func (enum AppInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AppInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AppSortKey string

// Enum values for AppSortKey
const (
	AppSortKeyCreationTime AppSortKey = "CreationTime"
)

func (enum AppSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AppSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AppStatus string

// Enum values for AppStatus
const (
	AppStatusDeleted   AppStatus = "Deleted"
	AppStatusDeleting  AppStatus = "Deleting"
	AppStatusFailed    AppStatus = "Failed"
	AppStatusInService AppStatus = "InService"
	AppStatusPending   AppStatus = "Pending"
)

func (enum AppStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AppStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AppType string

// Enum values for AppType
const (
	AppTypeJupyterServer AppType = "JupyterServer"
	AppTypeKernelGateway AppType = "KernelGateway"
	AppTypeTensorBoard   AppType = "TensorBoard"
)

func (enum AppType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AppType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AssemblyType string

// Enum values for AssemblyType
const (
	AssemblyTypeNone AssemblyType = "None"
	AssemblyTypeLine AssemblyType = "Line"
)

func (enum AssemblyType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AssemblyType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AuthMode string

// Enum values for AuthMode
const (
	AuthModeSso AuthMode = "SSO"
	AuthModeIam AuthMode = "IAM"
)

func (enum AuthMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AuthMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLJobObjectiveType string

// Enum values for AutoMLJobObjectiveType
const (
	AutoMLJobObjectiveTypeMaximize AutoMLJobObjectiveType = "Maximize"
	AutoMLJobObjectiveTypeMinimize AutoMLJobObjectiveType = "Minimize"
)

func (enum AutoMLJobObjectiveType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLJobObjectiveType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLJobSecondaryStatus string

// Enum values for AutoMLJobSecondaryStatus
const (
	AutoMLJobSecondaryStatusStarting                      AutoMLJobSecondaryStatus = "Starting"
	AutoMLJobSecondaryStatusAnalyzingData                 AutoMLJobSecondaryStatus = "AnalyzingData"
	AutoMLJobSecondaryStatusFeatureEngineering            AutoMLJobSecondaryStatus = "FeatureEngineering"
	AutoMLJobSecondaryStatusModelTuning                   AutoMLJobSecondaryStatus = "ModelTuning"
	AutoMLJobSecondaryStatusMaxCandidatesReached          AutoMLJobSecondaryStatus = "MaxCandidatesReached"
	AutoMLJobSecondaryStatusFailed                        AutoMLJobSecondaryStatus = "Failed"
	AutoMLJobSecondaryStatusStopped                       AutoMLJobSecondaryStatus = "Stopped"
	AutoMLJobSecondaryStatusMaxAutoMljobRuntimeReached    AutoMLJobSecondaryStatus = "MaxAutoMLJobRuntimeReached"
	AutoMLJobSecondaryStatusStopping                      AutoMLJobSecondaryStatus = "Stopping"
	AutoMLJobSecondaryStatusCandidateDefinitionsGenerated AutoMLJobSecondaryStatus = "CandidateDefinitionsGenerated"
)

func (enum AutoMLJobSecondaryStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLJobSecondaryStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLJobStatus string

// Enum values for AutoMLJobStatus
const (
	AutoMLJobStatusCompleted  AutoMLJobStatus = "Completed"
	AutoMLJobStatusInProgress AutoMLJobStatus = "InProgress"
	AutoMLJobStatusFailed     AutoMLJobStatus = "Failed"
	AutoMLJobStatusStopped    AutoMLJobStatus = "Stopped"
	AutoMLJobStatusStopping   AutoMLJobStatus = "Stopping"
)

func (enum AutoMLJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLMetricEnum string

// Enum values for AutoMLMetricEnum
const (
	AutoMLMetricEnumAccuracy AutoMLMetricEnum = "Accuracy"
	AutoMLMetricEnumMse      AutoMLMetricEnum = "MSE"
	AutoMLMetricEnumF1       AutoMLMetricEnum = "F1"
	AutoMLMetricEnumF1macro  AutoMLMetricEnum = "F1macro"
)

func (enum AutoMLMetricEnum) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLMetricEnum) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLS3DataType string

// Enum values for AutoMLS3DataType
const (
	AutoMLS3DataTypeManifestFile AutoMLS3DataType = "ManifestFile"
	AutoMLS3DataTypeS3prefix     AutoMLS3DataType = "S3Prefix"
)

func (enum AutoMLS3DataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLS3DataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLSortBy string

// Enum values for AutoMLSortBy
const (
	AutoMLSortByName         AutoMLSortBy = "Name"
	AutoMLSortByCreationTime AutoMLSortBy = "CreationTime"
	AutoMLSortByStatus       AutoMLSortBy = "Status"
)

func (enum AutoMLSortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLSortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AutoMLSortOrder string

// Enum values for AutoMLSortOrder
const (
	AutoMLSortOrderAscending  AutoMLSortOrder = "Ascending"
	AutoMLSortOrderDescending AutoMLSortOrder = "Descending"
)

func (enum AutoMLSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AutoMLSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type AwsManagedHumanLoopRequestSource string

// Enum values for AwsManagedHumanLoopRequestSource
const (
	AwsManagedHumanLoopRequestSourceAwsRekognitionDetectModerationLabelsImageV3 AwsManagedHumanLoopRequestSource = "AWS/Rekognition/DetectModerationLabels/Image/V3"
	AwsManagedHumanLoopRequestSourceAwsTextractAnalyzeDocumentFormsV1           AwsManagedHumanLoopRequestSource = "AWS/Textract/AnalyzeDocument/Forms/V1"
)

func (enum AwsManagedHumanLoopRequestSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AwsManagedHumanLoopRequestSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type BatchStrategy string

// Enum values for BatchStrategy
const (
	BatchStrategyMultiRecord  BatchStrategy = "MultiRecord"
	BatchStrategySingleRecord BatchStrategy = "SingleRecord"
)

func (enum BatchStrategy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BatchStrategy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type BooleanOperator string

// Enum values for BooleanOperator
const (
	BooleanOperatorAnd BooleanOperator = "And"
	BooleanOperatorOr  BooleanOperator = "Or"
)

func (enum BooleanOperator) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BooleanOperator) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CandidateSortBy string

// Enum values for CandidateSortBy
const (
	CandidateSortByCreationTime              CandidateSortBy = "CreationTime"
	CandidateSortByStatus                    CandidateSortBy = "Status"
	CandidateSortByFinalObjectiveMetricValue CandidateSortBy = "FinalObjectiveMetricValue"
)

func (enum CandidateSortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CandidateSortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CandidateStatus string

// Enum values for CandidateStatus
const (
	CandidateStatusCompleted  CandidateStatus = "Completed"
	CandidateStatusInProgress CandidateStatus = "InProgress"
	CandidateStatusFailed     CandidateStatus = "Failed"
	CandidateStatusStopped    CandidateStatus = "Stopped"
	CandidateStatusStopping   CandidateStatus = "Stopping"
)

func (enum CandidateStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CandidateStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CandidateStepType string

// Enum values for CandidateStepType
const (
	CandidateStepTypeAwsSageMakerTrainingJob   CandidateStepType = "AWS::SageMaker::TrainingJob"
	CandidateStepTypeAwsSageMakerTransformJob  CandidateStepType = "AWS::SageMaker::TransformJob"
	CandidateStepTypeAwsSageMakerProcessingJob CandidateStepType = "AWS::SageMaker::ProcessingJob"
)

func (enum CandidateStepType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CandidateStepType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CaptureMode string

// Enum values for CaptureMode
const (
	CaptureModeInput  CaptureMode = "Input"
	CaptureModeOutput CaptureMode = "Output"
)

func (enum CaptureMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CaptureMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CaptureStatus string

// Enum values for CaptureStatus
const (
	CaptureStatusStarted CaptureStatus = "Started"
	CaptureStatusStopped CaptureStatus = "Stopped"
)

func (enum CaptureStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CaptureStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CodeRepositorySortBy string

// Enum values for CodeRepositorySortBy
const (
	CodeRepositorySortByName             CodeRepositorySortBy = "Name"
	CodeRepositorySortByCreationTime     CodeRepositorySortBy = "CreationTime"
	CodeRepositorySortByLastModifiedTime CodeRepositorySortBy = "LastModifiedTime"
)

func (enum CodeRepositorySortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CodeRepositorySortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CodeRepositorySortOrder string

// Enum values for CodeRepositorySortOrder
const (
	CodeRepositorySortOrderAscending  CodeRepositorySortOrder = "Ascending"
	CodeRepositorySortOrderDescending CodeRepositorySortOrder = "Descending"
)

func (enum CodeRepositorySortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CodeRepositorySortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CompilationJobStatus string

// Enum values for CompilationJobStatus
const (
	CompilationJobStatusInprogress CompilationJobStatus = "INPROGRESS"
	CompilationJobStatusCompleted  CompilationJobStatus = "COMPLETED"
	CompilationJobStatusFailed     CompilationJobStatus = "FAILED"
	CompilationJobStatusStarting   CompilationJobStatus = "STARTING"
	CompilationJobStatusStopping   CompilationJobStatus = "STOPPING"
	CompilationJobStatusStopped    CompilationJobStatus = "STOPPED"
)

func (enum CompilationJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CompilationJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type CompressionType string

// Enum values for CompressionType
const (
	CompressionTypeNone CompressionType = "None"
	CompressionTypeGzip CompressionType = "Gzip"
)

func (enum CompressionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum CompressionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ContainerMode string

// Enum values for ContainerMode
const (
	ContainerModeSingleModel ContainerMode = "SingleModel"
	ContainerModeMultiModel  ContainerMode = "MultiModel"
)

func (enum ContainerMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ContainerMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ContentClassifier string

// Enum values for ContentClassifier
const (
	ContentClassifierFreeOfPersonallyIdentifiableInformation ContentClassifier = "FreeOfPersonallyIdentifiableInformation"
	ContentClassifierFreeOfAdultContent                      ContentClassifier = "FreeOfAdultContent"
)

func (enum ContentClassifier) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ContentClassifier) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DetailedAlgorithmStatus string

// Enum values for DetailedAlgorithmStatus
const (
	DetailedAlgorithmStatusNotStarted DetailedAlgorithmStatus = "NotStarted"
	DetailedAlgorithmStatusInProgress DetailedAlgorithmStatus = "InProgress"
	DetailedAlgorithmStatusCompleted  DetailedAlgorithmStatus = "Completed"
	DetailedAlgorithmStatusFailed     DetailedAlgorithmStatus = "Failed"
)

func (enum DetailedAlgorithmStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DetailedAlgorithmStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DetailedModelPackageStatus string

// Enum values for DetailedModelPackageStatus
const (
	DetailedModelPackageStatusNotStarted DetailedModelPackageStatus = "NotStarted"
	DetailedModelPackageStatusInProgress DetailedModelPackageStatus = "InProgress"
	DetailedModelPackageStatusCompleted  DetailedModelPackageStatus = "Completed"
	DetailedModelPackageStatusFailed     DetailedModelPackageStatus = "Failed"
)

func (enum DetailedModelPackageStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DetailedModelPackageStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DirectInternetAccess string

// Enum values for DirectInternetAccess
const (
	DirectInternetAccessEnabled  DirectInternetAccess = "Enabled"
	DirectInternetAccessDisabled DirectInternetAccess = "Disabled"
)

func (enum DirectInternetAccess) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DirectInternetAccess) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type DomainStatus string

// Enum values for DomainStatus
const (
	DomainStatusDeleting  DomainStatus = "Deleting"
	DomainStatusFailed    DomainStatus = "Failed"
	DomainStatusInService DomainStatus = "InService"
	DomainStatusPending   DomainStatus = "Pending"
)

func (enum DomainStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DomainStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointConfigSortKey string

// Enum values for EndpointConfigSortKey
const (
	EndpointConfigSortKeyName         EndpointConfigSortKey = "Name"
	EndpointConfigSortKeyCreationTime EndpointConfigSortKey = "CreationTime"
)

func (enum EndpointConfigSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointConfigSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointSortKey string

// Enum values for EndpointSortKey
const (
	EndpointSortKeyName         EndpointSortKey = "Name"
	EndpointSortKeyCreationTime EndpointSortKey = "CreationTime"
	EndpointSortKeyStatus       EndpointSortKey = "Status"
)

func (enum EndpointSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type EndpointStatus string

// Enum values for EndpointStatus
const (
	EndpointStatusOutOfService   EndpointStatus = "OutOfService"
	EndpointStatusCreating       EndpointStatus = "Creating"
	EndpointStatusUpdating       EndpointStatus = "Updating"
	EndpointStatusSystemUpdating EndpointStatus = "SystemUpdating"
	EndpointStatusRollingBack    EndpointStatus = "RollingBack"
	EndpointStatusInService      EndpointStatus = "InService"
	EndpointStatusDeleting       EndpointStatus = "Deleting"
	EndpointStatusFailed         EndpointStatus = "Failed"
)

func (enum EndpointStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ExecutionStatus string

// Enum values for ExecutionStatus
const (
	ExecutionStatusPending                 ExecutionStatus = "Pending"
	ExecutionStatusCompleted               ExecutionStatus = "Completed"
	ExecutionStatusCompletedWithViolations ExecutionStatus = "CompletedWithViolations"
	ExecutionStatusInProgress              ExecutionStatus = "InProgress"
	ExecutionStatusFailed                  ExecutionStatus = "Failed"
	ExecutionStatusStopping                ExecutionStatus = "Stopping"
	ExecutionStatusStopped                 ExecutionStatus = "Stopped"
)

func (enum ExecutionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ExecutionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type FileSystemAccessMode string

// Enum values for FileSystemAccessMode
const (
	FileSystemAccessModeRw FileSystemAccessMode = "rw"
	FileSystemAccessModeRo FileSystemAccessMode = "ro"
)

func (enum FileSystemAccessMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FileSystemAccessMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type FileSystemType string

// Enum values for FileSystemType
const (
	FileSystemTypeEfs       FileSystemType = "EFS"
	FileSystemTypeFsxLustre FileSystemType = "FSxLustre"
)

func (enum FileSystemType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FileSystemType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type FlowDefinitionStatus string

// Enum values for FlowDefinitionStatus
const (
	FlowDefinitionStatusInitializing FlowDefinitionStatus = "Initializing"
	FlowDefinitionStatusActive       FlowDefinitionStatus = "Active"
	FlowDefinitionStatusFailed       FlowDefinitionStatus = "Failed"
	FlowDefinitionStatusDeleting     FlowDefinitionStatus = "Deleting"
	FlowDefinitionStatusDeleted      FlowDefinitionStatus = "Deleted"
)

func (enum FlowDefinitionStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FlowDefinitionStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type Framework string

// Enum values for Framework
const (
	FrameworkTensorflow Framework = "TENSORFLOW"
	FrameworkMxnet      Framework = "MXNET"
	FrameworkOnnx       Framework = "ONNX"
	FrameworkPytorch    Framework = "PYTORCH"
	FrameworkXgboost    Framework = "XGBOOST"
)

func (enum Framework) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Framework) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type HyperParameterScalingType string

// Enum values for HyperParameterScalingType
const (
	HyperParameterScalingTypeAuto               HyperParameterScalingType = "Auto"
	HyperParameterScalingTypeLinear             HyperParameterScalingType = "Linear"
	HyperParameterScalingTypeLogarithmic        HyperParameterScalingType = "Logarithmic"
	HyperParameterScalingTypeReverseLogarithmic HyperParameterScalingType = "ReverseLogarithmic"
)

func (enum HyperParameterScalingType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterScalingType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type HyperParameterTuningJobObjectiveType string

// Enum values for HyperParameterTuningJobObjectiveType
const (
	HyperParameterTuningJobObjectiveTypeMaximize HyperParameterTuningJobObjectiveType = "Maximize"
	HyperParameterTuningJobObjectiveTypeMinimize HyperParameterTuningJobObjectiveType = "Minimize"
)

func (enum HyperParameterTuningJobObjectiveType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterTuningJobObjectiveType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type HyperParameterTuningJobSortByOptions string

// Enum values for HyperParameterTuningJobSortByOptions
const (
	HyperParameterTuningJobSortByOptionsName         HyperParameterTuningJobSortByOptions = "Name"
	HyperParameterTuningJobSortByOptionsStatus       HyperParameterTuningJobSortByOptions = "Status"
	HyperParameterTuningJobSortByOptionsCreationTime HyperParameterTuningJobSortByOptions = "CreationTime"
)

func (enum HyperParameterTuningJobSortByOptions) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterTuningJobSortByOptions) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type HyperParameterTuningJobStatus string

// Enum values for HyperParameterTuningJobStatus
const (
	HyperParameterTuningJobStatusCompleted  HyperParameterTuningJobStatus = "Completed"
	HyperParameterTuningJobStatusInProgress HyperParameterTuningJobStatus = "InProgress"
	HyperParameterTuningJobStatusFailed     HyperParameterTuningJobStatus = "Failed"
	HyperParameterTuningJobStatusStopped    HyperParameterTuningJobStatus = "Stopped"
	HyperParameterTuningJobStatusStopping   HyperParameterTuningJobStatus = "Stopping"
)

func (enum HyperParameterTuningJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterTuningJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The strategy hyperparameter tuning uses to find the best combination of hyperparameters
// for your model. Currently, the only supported value is Bayesian.
type HyperParameterTuningJobStrategyType string

// Enum values for HyperParameterTuningJobStrategyType
const (
	HyperParameterTuningJobStrategyTypeBayesian HyperParameterTuningJobStrategyType = "Bayesian"
	HyperParameterTuningJobStrategyTypeRandom   HyperParameterTuningJobStrategyType = "Random"
)

func (enum HyperParameterTuningJobStrategyType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterTuningJobStrategyType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type HyperParameterTuningJobWarmStartType string

// Enum values for HyperParameterTuningJobWarmStartType
const (
	HyperParameterTuningJobWarmStartTypeIdenticalDataAndAlgorithm HyperParameterTuningJobWarmStartType = "IdenticalDataAndAlgorithm"
	HyperParameterTuningJobWarmStartTypeTransferLearning          HyperParameterTuningJobWarmStartType = "TransferLearning"
)

func (enum HyperParameterTuningJobWarmStartType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HyperParameterTuningJobWarmStartType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InstanceType string

// Enum values for InstanceType
const (
	InstanceTypeMlT2Medium    InstanceType = "ml.t2.medium"
	InstanceTypeMlT2Large     InstanceType = "ml.t2.large"
	InstanceTypeMlT2Xlarge    InstanceType = "ml.t2.xlarge"
	InstanceTypeMlT22xlarge   InstanceType = "ml.t2.2xlarge"
	InstanceTypeMlT3Medium    InstanceType = "ml.t3.medium"
	InstanceTypeMlT3Large     InstanceType = "ml.t3.large"
	InstanceTypeMlT3Xlarge    InstanceType = "ml.t3.xlarge"
	InstanceTypeMlT32xlarge   InstanceType = "ml.t3.2xlarge"
	InstanceTypeMlM4Xlarge    InstanceType = "ml.m4.xlarge"
	InstanceTypeMlM42xlarge   InstanceType = "ml.m4.2xlarge"
	InstanceTypeMlM44xlarge   InstanceType = "ml.m4.4xlarge"
	InstanceTypeMlM410xlarge  InstanceType = "ml.m4.10xlarge"
	InstanceTypeMlM416xlarge  InstanceType = "ml.m4.16xlarge"
	InstanceTypeMlM5Xlarge    InstanceType = "ml.m5.xlarge"
	InstanceTypeMlM52xlarge   InstanceType = "ml.m5.2xlarge"
	InstanceTypeMlM54xlarge   InstanceType = "ml.m5.4xlarge"
	InstanceTypeMlM512xlarge  InstanceType = "ml.m5.12xlarge"
	InstanceTypeMlM524xlarge  InstanceType = "ml.m5.24xlarge"
	InstanceTypeMlC4Xlarge    InstanceType = "ml.c4.xlarge"
	InstanceTypeMlC42xlarge   InstanceType = "ml.c4.2xlarge"
	InstanceTypeMlC44xlarge   InstanceType = "ml.c4.4xlarge"
	InstanceTypeMlC48xlarge   InstanceType = "ml.c4.8xlarge"
	InstanceTypeMlC5Xlarge    InstanceType = "ml.c5.xlarge"
	InstanceTypeMlC52xlarge   InstanceType = "ml.c5.2xlarge"
	InstanceTypeMlC54xlarge   InstanceType = "ml.c5.4xlarge"
	InstanceTypeMlC59xlarge   InstanceType = "ml.c5.9xlarge"
	InstanceTypeMlC518xlarge  InstanceType = "ml.c5.18xlarge"
	InstanceTypeMlC5dXlarge   InstanceType = "ml.c5d.xlarge"
	InstanceTypeMlC5d2xlarge  InstanceType = "ml.c5d.2xlarge"
	InstanceTypeMlC5d4xlarge  InstanceType = "ml.c5d.4xlarge"
	InstanceTypeMlC5d9xlarge  InstanceType = "ml.c5d.9xlarge"
	InstanceTypeMlC5d18xlarge InstanceType = "ml.c5d.18xlarge"
	InstanceTypeMlP2Xlarge    InstanceType = "ml.p2.xlarge"
	InstanceTypeMlP28xlarge   InstanceType = "ml.p2.8xlarge"
	InstanceTypeMlP216xlarge  InstanceType = "ml.p2.16xlarge"
	InstanceTypeMlP32xlarge   InstanceType = "ml.p3.2xlarge"
	InstanceTypeMlP38xlarge   InstanceType = "ml.p3.8xlarge"
	InstanceTypeMlP316xlarge  InstanceType = "ml.p3.16xlarge"
)

func (enum InstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type JoinSource string

// Enum values for JoinSource
const (
	JoinSourceInput JoinSource = "Input"
	JoinSourceNone  JoinSource = "None"
)

func (enum JoinSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum JoinSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type LabelingJobStatus string

// Enum values for LabelingJobStatus
const (
	LabelingJobStatusInProgress LabelingJobStatus = "InProgress"
	LabelingJobStatusCompleted  LabelingJobStatus = "Completed"
	LabelingJobStatusFailed     LabelingJobStatus = "Failed"
	LabelingJobStatusStopping   LabelingJobStatus = "Stopping"
	LabelingJobStatusStopped    LabelingJobStatus = "Stopped"
)

func (enum LabelingJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum LabelingJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ListCompilationJobsSortBy string

// Enum values for ListCompilationJobsSortBy
const (
	ListCompilationJobsSortByName         ListCompilationJobsSortBy = "Name"
	ListCompilationJobsSortByCreationTime ListCompilationJobsSortBy = "CreationTime"
	ListCompilationJobsSortByStatus       ListCompilationJobsSortBy = "Status"
)

func (enum ListCompilationJobsSortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ListCompilationJobsSortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ListLabelingJobsForWorkteamSortByOptions string

// Enum values for ListLabelingJobsForWorkteamSortByOptions
const (
	ListLabelingJobsForWorkteamSortByOptionsCreationTime ListLabelingJobsForWorkteamSortByOptions = "CreationTime"
)

func (enum ListLabelingJobsForWorkteamSortByOptions) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ListLabelingJobsForWorkteamSortByOptions) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ListWorkteamsSortByOptions string

// Enum values for ListWorkteamsSortByOptions
const (
	ListWorkteamsSortByOptionsName       ListWorkteamsSortByOptions = "Name"
	ListWorkteamsSortByOptionsCreateDate ListWorkteamsSortByOptions = "CreateDate"
)

func (enum ListWorkteamsSortByOptions) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ListWorkteamsSortByOptions) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ModelPackageSortBy string

// Enum values for ModelPackageSortBy
const (
	ModelPackageSortByName         ModelPackageSortBy = "Name"
	ModelPackageSortByCreationTime ModelPackageSortBy = "CreationTime"
)

func (enum ModelPackageSortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ModelPackageSortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ModelPackageStatus string

// Enum values for ModelPackageStatus
const (
	ModelPackageStatusPending    ModelPackageStatus = "Pending"
	ModelPackageStatusInProgress ModelPackageStatus = "InProgress"
	ModelPackageStatusCompleted  ModelPackageStatus = "Completed"
	ModelPackageStatusFailed     ModelPackageStatus = "Failed"
	ModelPackageStatusDeleting   ModelPackageStatus = "Deleting"
)

func (enum ModelPackageStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ModelPackageStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ModelSortKey string

// Enum values for ModelSortKey
const (
	ModelSortKeyName         ModelSortKey = "Name"
	ModelSortKeyCreationTime ModelSortKey = "CreationTime"
)

func (enum ModelSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ModelSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type MonitoringExecutionSortKey string

// Enum values for MonitoringExecutionSortKey
const (
	MonitoringExecutionSortKeyCreationTime  MonitoringExecutionSortKey = "CreationTime"
	MonitoringExecutionSortKeyScheduledTime MonitoringExecutionSortKey = "ScheduledTime"
	MonitoringExecutionSortKeyStatus        MonitoringExecutionSortKey = "Status"
)

func (enum MonitoringExecutionSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MonitoringExecutionSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type MonitoringScheduleSortKey string

// Enum values for MonitoringScheduleSortKey
const (
	MonitoringScheduleSortKeyName         MonitoringScheduleSortKey = "Name"
	MonitoringScheduleSortKeyCreationTime MonitoringScheduleSortKey = "CreationTime"
	MonitoringScheduleSortKeyStatus       MonitoringScheduleSortKey = "Status"
)

func (enum MonitoringScheduleSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MonitoringScheduleSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceAcceleratorType string

// Enum values for NotebookInstanceAcceleratorType
const (
	NotebookInstanceAcceleratorTypeMlEia1Medium NotebookInstanceAcceleratorType = "ml.eia1.medium"
	NotebookInstanceAcceleratorTypeMlEia1Large  NotebookInstanceAcceleratorType = "ml.eia1.large"
	NotebookInstanceAcceleratorTypeMlEia1Xlarge NotebookInstanceAcceleratorType = "ml.eia1.xlarge"
	NotebookInstanceAcceleratorTypeMlEia2Medium NotebookInstanceAcceleratorType = "ml.eia2.medium"
	NotebookInstanceAcceleratorTypeMlEia2Large  NotebookInstanceAcceleratorType = "ml.eia2.large"
	NotebookInstanceAcceleratorTypeMlEia2Xlarge NotebookInstanceAcceleratorType = "ml.eia2.xlarge"
)

func (enum NotebookInstanceAcceleratorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceAcceleratorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceLifecycleConfigSortKey string

// Enum values for NotebookInstanceLifecycleConfigSortKey
const (
	NotebookInstanceLifecycleConfigSortKeyName             NotebookInstanceLifecycleConfigSortKey = "Name"
	NotebookInstanceLifecycleConfigSortKeyCreationTime     NotebookInstanceLifecycleConfigSortKey = "CreationTime"
	NotebookInstanceLifecycleConfigSortKeyLastModifiedTime NotebookInstanceLifecycleConfigSortKey = "LastModifiedTime"
)

func (enum NotebookInstanceLifecycleConfigSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceLifecycleConfigSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceLifecycleConfigSortOrder string

// Enum values for NotebookInstanceLifecycleConfigSortOrder
const (
	NotebookInstanceLifecycleConfigSortOrderAscending  NotebookInstanceLifecycleConfigSortOrder = "Ascending"
	NotebookInstanceLifecycleConfigSortOrderDescending NotebookInstanceLifecycleConfigSortOrder = "Descending"
)

func (enum NotebookInstanceLifecycleConfigSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceLifecycleConfigSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceSortKey string

// Enum values for NotebookInstanceSortKey
const (
	NotebookInstanceSortKeyName         NotebookInstanceSortKey = "Name"
	NotebookInstanceSortKeyCreationTime NotebookInstanceSortKey = "CreationTime"
	NotebookInstanceSortKeyStatus       NotebookInstanceSortKey = "Status"
)

func (enum NotebookInstanceSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceSortOrder string

// Enum values for NotebookInstanceSortOrder
const (
	NotebookInstanceSortOrderAscending  NotebookInstanceSortOrder = "Ascending"
	NotebookInstanceSortOrderDescending NotebookInstanceSortOrder = "Descending"
)

func (enum NotebookInstanceSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookInstanceStatus string

// Enum values for NotebookInstanceStatus
const (
	NotebookInstanceStatusPending   NotebookInstanceStatus = "Pending"
	NotebookInstanceStatusInService NotebookInstanceStatus = "InService"
	NotebookInstanceStatusStopping  NotebookInstanceStatus = "Stopping"
	NotebookInstanceStatusStopped   NotebookInstanceStatus = "Stopped"
	NotebookInstanceStatusFailed    NotebookInstanceStatus = "Failed"
	NotebookInstanceStatusDeleting  NotebookInstanceStatus = "Deleting"
	NotebookInstanceStatusUpdating  NotebookInstanceStatus = "Updating"
)

func (enum NotebookInstanceStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookInstanceStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type NotebookOutputOption string

// Enum values for NotebookOutputOption
const (
	NotebookOutputOptionAllowed  NotebookOutputOption = "Allowed"
	NotebookOutputOptionDisabled NotebookOutputOption = "Disabled"
)

func (enum NotebookOutputOption) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NotebookOutputOption) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ObjectiveStatus string

// Enum values for ObjectiveStatus
const (
	ObjectiveStatusSucceeded ObjectiveStatus = "Succeeded"
	ObjectiveStatusPending   ObjectiveStatus = "Pending"
	ObjectiveStatusFailed    ObjectiveStatus = "Failed"
)

func (enum ObjectiveStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ObjectiveStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type Operator string

// Enum values for Operator
const (
	OperatorEquals               Operator = "Equals"
	OperatorNotEquals            Operator = "NotEquals"
	OperatorGreaterThan          Operator = "GreaterThan"
	OperatorGreaterThanOrEqualTo Operator = "GreaterThanOrEqualTo"
	OperatorLessThan             Operator = "LessThan"
	OperatorLessThanOrEqualTo    Operator = "LessThanOrEqualTo"
	OperatorContains             Operator = "Contains"
	OperatorExists               Operator = "Exists"
	OperatorNotExists            Operator = "NotExists"
)

func (enum Operator) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Operator) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type OrderKey string

// Enum values for OrderKey
const (
	OrderKeyAscending  OrderKey = "Ascending"
	OrderKeyDescending OrderKey = "Descending"
)

func (enum OrderKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OrderKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ParameterType string

// Enum values for ParameterType
const (
	ParameterTypeInteger     ParameterType = "Integer"
	ParameterTypeContinuous  ParameterType = "Continuous"
	ParameterTypeCategorical ParameterType = "Categorical"
	ParameterTypeFreeText    ParameterType = "FreeText"
)

func (enum ParameterType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ParameterType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProblemType string

// Enum values for ProblemType
const (
	ProblemTypeBinaryClassification     ProblemType = "BinaryClassification"
	ProblemTypeMulticlassClassification ProblemType = "MulticlassClassification"
	ProblemTypeRegression               ProblemType = "Regression"
)

func (enum ProblemType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProblemType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingInstanceType string

// Enum values for ProcessingInstanceType
const (
	ProcessingInstanceTypeMlT3Medium   ProcessingInstanceType = "ml.t3.medium"
	ProcessingInstanceTypeMlT3Large    ProcessingInstanceType = "ml.t3.large"
	ProcessingInstanceTypeMlT3Xlarge   ProcessingInstanceType = "ml.t3.xlarge"
	ProcessingInstanceTypeMlT32xlarge  ProcessingInstanceType = "ml.t3.2xlarge"
	ProcessingInstanceTypeMlM4Xlarge   ProcessingInstanceType = "ml.m4.xlarge"
	ProcessingInstanceTypeMlM42xlarge  ProcessingInstanceType = "ml.m4.2xlarge"
	ProcessingInstanceTypeMlM44xlarge  ProcessingInstanceType = "ml.m4.4xlarge"
	ProcessingInstanceTypeMlM410xlarge ProcessingInstanceType = "ml.m4.10xlarge"
	ProcessingInstanceTypeMlM416xlarge ProcessingInstanceType = "ml.m4.16xlarge"
	ProcessingInstanceTypeMlC4Xlarge   ProcessingInstanceType = "ml.c4.xlarge"
	ProcessingInstanceTypeMlC42xlarge  ProcessingInstanceType = "ml.c4.2xlarge"
	ProcessingInstanceTypeMlC44xlarge  ProcessingInstanceType = "ml.c4.4xlarge"
	ProcessingInstanceTypeMlC48xlarge  ProcessingInstanceType = "ml.c4.8xlarge"
	ProcessingInstanceTypeMlP2Xlarge   ProcessingInstanceType = "ml.p2.xlarge"
	ProcessingInstanceTypeMlP28xlarge  ProcessingInstanceType = "ml.p2.8xlarge"
	ProcessingInstanceTypeMlP216xlarge ProcessingInstanceType = "ml.p2.16xlarge"
	ProcessingInstanceTypeMlP32xlarge  ProcessingInstanceType = "ml.p3.2xlarge"
	ProcessingInstanceTypeMlP38xlarge  ProcessingInstanceType = "ml.p3.8xlarge"
	ProcessingInstanceTypeMlP316xlarge ProcessingInstanceType = "ml.p3.16xlarge"
	ProcessingInstanceTypeMlC5Xlarge   ProcessingInstanceType = "ml.c5.xlarge"
	ProcessingInstanceTypeMlC52xlarge  ProcessingInstanceType = "ml.c5.2xlarge"
	ProcessingInstanceTypeMlC54xlarge  ProcessingInstanceType = "ml.c5.4xlarge"
	ProcessingInstanceTypeMlC59xlarge  ProcessingInstanceType = "ml.c5.9xlarge"
	ProcessingInstanceTypeMlC518xlarge ProcessingInstanceType = "ml.c5.18xlarge"
	ProcessingInstanceTypeMlM5Large    ProcessingInstanceType = "ml.m5.large"
	ProcessingInstanceTypeMlM5Xlarge   ProcessingInstanceType = "ml.m5.xlarge"
	ProcessingInstanceTypeMlM52xlarge  ProcessingInstanceType = "ml.m5.2xlarge"
	ProcessingInstanceTypeMlM54xlarge  ProcessingInstanceType = "ml.m5.4xlarge"
	ProcessingInstanceTypeMlM512xlarge ProcessingInstanceType = "ml.m5.12xlarge"
	ProcessingInstanceTypeMlM524xlarge ProcessingInstanceType = "ml.m5.24xlarge"
	ProcessingInstanceTypeMlR5Large    ProcessingInstanceType = "ml.r5.large"
	ProcessingInstanceTypeMlR5Xlarge   ProcessingInstanceType = "ml.r5.xlarge"
	ProcessingInstanceTypeMlR52xlarge  ProcessingInstanceType = "ml.r5.2xlarge"
	ProcessingInstanceTypeMlR54xlarge  ProcessingInstanceType = "ml.r5.4xlarge"
	ProcessingInstanceTypeMlR58xlarge  ProcessingInstanceType = "ml.r5.8xlarge"
	ProcessingInstanceTypeMlR512xlarge ProcessingInstanceType = "ml.r5.12xlarge"
	ProcessingInstanceTypeMlR516xlarge ProcessingInstanceType = "ml.r5.16xlarge"
	ProcessingInstanceTypeMlR524xlarge ProcessingInstanceType = "ml.r5.24xlarge"
)

func (enum ProcessingInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingJobStatus string

// Enum values for ProcessingJobStatus
const (
	ProcessingJobStatusInProgress ProcessingJobStatus = "InProgress"
	ProcessingJobStatusCompleted  ProcessingJobStatus = "Completed"
	ProcessingJobStatusFailed     ProcessingJobStatus = "Failed"
	ProcessingJobStatusStopping   ProcessingJobStatus = "Stopping"
	ProcessingJobStatusStopped    ProcessingJobStatus = "Stopped"
)

func (enum ProcessingJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingS3CompressionType string

// Enum values for ProcessingS3CompressionType
const (
	ProcessingS3CompressionTypeNone ProcessingS3CompressionType = "None"
	ProcessingS3CompressionTypeGzip ProcessingS3CompressionType = "Gzip"
)

func (enum ProcessingS3CompressionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingS3CompressionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingS3DataDistributionType string

// Enum values for ProcessingS3DataDistributionType
const (
	ProcessingS3DataDistributionTypeFullyReplicated ProcessingS3DataDistributionType = "FullyReplicated"
	ProcessingS3DataDistributionTypeShardedByS3key  ProcessingS3DataDistributionType = "ShardedByS3Key"
)

func (enum ProcessingS3DataDistributionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingS3DataDistributionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingS3DataType string

// Enum values for ProcessingS3DataType
const (
	ProcessingS3DataTypeManifestFile ProcessingS3DataType = "ManifestFile"
	ProcessingS3DataTypeS3prefix     ProcessingS3DataType = "S3Prefix"
)

func (enum ProcessingS3DataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingS3DataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingS3InputMode string

// Enum values for ProcessingS3InputMode
const (
	ProcessingS3InputModePipe ProcessingS3InputMode = "Pipe"
	ProcessingS3InputModeFile ProcessingS3InputMode = "File"
)

func (enum ProcessingS3InputMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingS3InputMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProcessingS3UploadMode string

// Enum values for ProcessingS3UploadMode
const (
	ProcessingS3UploadModeContinuous ProcessingS3UploadMode = "Continuous"
	ProcessingS3UploadModeEndOfJob   ProcessingS3UploadMode = "EndOfJob"
)

func (enum ProcessingS3UploadMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProcessingS3UploadMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProductionVariantAcceleratorType string

// Enum values for ProductionVariantAcceleratorType
const (
	ProductionVariantAcceleratorTypeMlEia1Medium ProductionVariantAcceleratorType = "ml.eia1.medium"
	ProductionVariantAcceleratorTypeMlEia1Large  ProductionVariantAcceleratorType = "ml.eia1.large"
	ProductionVariantAcceleratorTypeMlEia1Xlarge ProductionVariantAcceleratorType = "ml.eia1.xlarge"
	ProductionVariantAcceleratorTypeMlEia2Medium ProductionVariantAcceleratorType = "ml.eia2.medium"
	ProductionVariantAcceleratorTypeMlEia2Large  ProductionVariantAcceleratorType = "ml.eia2.large"
	ProductionVariantAcceleratorTypeMlEia2Xlarge ProductionVariantAcceleratorType = "ml.eia2.xlarge"
)

func (enum ProductionVariantAcceleratorType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProductionVariantAcceleratorType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ProductionVariantInstanceType string

// Enum values for ProductionVariantInstanceType
const (
	ProductionVariantInstanceTypeMlT2Medium     ProductionVariantInstanceType = "ml.t2.medium"
	ProductionVariantInstanceTypeMlT2Large      ProductionVariantInstanceType = "ml.t2.large"
	ProductionVariantInstanceTypeMlT2Xlarge     ProductionVariantInstanceType = "ml.t2.xlarge"
	ProductionVariantInstanceTypeMlT22xlarge    ProductionVariantInstanceType = "ml.t2.2xlarge"
	ProductionVariantInstanceTypeMlM4Xlarge     ProductionVariantInstanceType = "ml.m4.xlarge"
	ProductionVariantInstanceTypeMlM42xlarge    ProductionVariantInstanceType = "ml.m4.2xlarge"
	ProductionVariantInstanceTypeMlM44xlarge    ProductionVariantInstanceType = "ml.m4.4xlarge"
	ProductionVariantInstanceTypeMlM410xlarge   ProductionVariantInstanceType = "ml.m4.10xlarge"
	ProductionVariantInstanceTypeMlM416xlarge   ProductionVariantInstanceType = "ml.m4.16xlarge"
	ProductionVariantInstanceTypeMlM5Large      ProductionVariantInstanceType = "ml.m5.large"
	ProductionVariantInstanceTypeMlM5Xlarge     ProductionVariantInstanceType = "ml.m5.xlarge"
	ProductionVariantInstanceTypeMlM52xlarge    ProductionVariantInstanceType = "ml.m5.2xlarge"
	ProductionVariantInstanceTypeMlM54xlarge    ProductionVariantInstanceType = "ml.m5.4xlarge"
	ProductionVariantInstanceTypeMlM512xlarge   ProductionVariantInstanceType = "ml.m5.12xlarge"
	ProductionVariantInstanceTypeMlM524xlarge   ProductionVariantInstanceType = "ml.m5.24xlarge"
	ProductionVariantInstanceTypeMlM5dLarge     ProductionVariantInstanceType = "ml.m5d.large"
	ProductionVariantInstanceTypeMlM5dXlarge    ProductionVariantInstanceType = "ml.m5d.xlarge"
	ProductionVariantInstanceTypeMlM5d2xlarge   ProductionVariantInstanceType = "ml.m5d.2xlarge"
	ProductionVariantInstanceTypeMlM5d4xlarge   ProductionVariantInstanceType = "ml.m5d.4xlarge"
	ProductionVariantInstanceTypeMlM5d12xlarge  ProductionVariantInstanceType = "ml.m5d.12xlarge"
	ProductionVariantInstanceTypeMlM5d24xlarge  ProductionVariantInstanceType = "ml.m5d.24xlarge"
	ProductionVariantInstanceTypeMlC4Large      ProductionVariantInstanceType = "ml.c4.large"
	ProductionVariantInstanceTypeMlC4Xlarge     ProductionVariantInstanceType = "ml.c4.xlarge"
	ProductionVariantInstanceTypeMlC42xlarge    ProductionVariantInstanceType = "ml.c4.2xlarge"
	ProductionVariantInstanceTypeMlC44xlarge    ProductionVariantInstanceType = "ml.c4.4xlarge"
	ProductionVariantInstanceTypeMlC48xlarge    ProductionVariantInstanceType = "ml.c4.8xlarge"
	ProductionVariantInstanceTypeMlP2Xlarge     ProductionVariantInstanceType = "ml.p2.xlarge"
	ProductionVariantInstanceTypeMlP28xlarge    ProductionVariantInstanceType = "ml.p2.8xlarge"
	ProductionVariantInstanceTypeMlP216xlarge   ProductionVariantInstanceType = "ml.p2.16xlarge"
	ProductionVariantInstanceTypeMlP32xlarge    ProductionVariantInstanceType = "ml.p3.2xlarge"
	ProductionVariantInstanceTypeMlP38xlarge    ProductionVariantInstanceType = "ml.p3.8xlarge"
	ProductionVariantInstanceTypeMlP316xlarge   ProductionVariantInstanceType = "ml.p3.16xlarge"
	ProductionVariantInstanceTypeMlC5Large      ProductionVariantInstanceType = "ml.c5.large"
	ProductionVariantInstanceTypeMlC5Xlarge     ProductionVariantInstanceType = "ml.c5.xlarge"
	ProductionVariantInstanceTypeMlC52xlarge    ProductionVariantInstanceType = "ml.c5.2xlarge"
	ProductionVariantInstanceTypeMlC54xlarge    ProductionVariantInstanceType = "ml.c5.4xlarge"
	ProductionVariantInstanceTypeMlC59xlarge    ProductionVariantInstanceType = "ml.c5.9xlarge"
	ProductionVariantInstanceTypeMlC518xlarge   ProductionVariantInstanceType = "ml.c5.18xlarge"
	ProductionVariantInstanceTypeMlC5dLarge     ProductionVariantInstanceType = "ml.c5d.large"
	ProductionVariantInstanceTypeMlC5dXlarge    ProductionVariantInstanceType = "ml.c5d.xlarge"
	ProductionVariantInstanceTypeMlC5d2xlarge   ProductionVariantInstanceType = "ml.c5d.2xlarge"
	ProductionVariantInstanceTypeMlC5d4xlarge   ProductionVariantInstanceType = "ml.c5d.4xlarge"
	ProductionVariantInstanceTypeMlC5d9xlarge   ProductionVariantInstanceType = "ml.c5d.9xlarge"
	ProductionVariantInstanceTypeMlC5d18xlarge  ProductionVariantInstanceType = "ml.c5d.18xlarge"
	ProductionVariantInstanceTypeMlG4dnXlarge   ProductionVariantInstanceType = "ml.g4dn.xlarge"
	ProductionVariantInstanceTypeMlG4dn2xlarge  ProductionVariantInstanceType = "ml.g4dn.2xlarge"
	ProductionVariantInstanceTypeMlG4dn4xlarge  ProductionVariantInstanceType = "ml.g4dn.4xlarge"
	ProductionVariantInstanceTypeMlG4dn8xlarge  ProductionVariantInstanceType = "ml.g4dn.8xlarge"
	ProductionVariantInstanceTypeMlG4dn12xlarge ProductionVariantInstanceType = "ml.g4dn.12xlarge"
	ProductionVariantInstanceTypeMlG4dn16xlarge ProductionVariantInstanceType = "ml.g4dn.16xlarge"
	ProductionVariantInstanceTypeMlR5Large      ProductionVariantInstanceType = "ml.r5.large"
	ProductionVariantInstanceTypeMlR5Xlarge     ProductionVariantInstanceType = "ml.r5.xlarge"
	ProductionVariantInstanceTypeMlR52xlarge    ProductionVariantInstanceType = "ml.r5.2xlarge"
	ProductionVariantInstanceTypeMlR54xlarge    ProductionVariantInstanceType = "ml.r5.4xlarge"
	ProductionVariantInstanceTypeMlR512xlarge   ProductionVariantInstanceType = "ml.r5.12xlarge"
	ProductionVariantInstanceTypeMlR524xlarge   ProductionVariantInstanceType = "ml.r5.24xlarge"
	ProductionVariantInstanceTypeMlR5dLarge     ProductionVariantInstanceType = "ml.r5d.large"
	ProductionVariantInstanceTypeMlR5dXlarge    ProductionVariantInstanceType = "ml.r5d.xlarge"
	ProductionVariantInstanceTypeMlR5d2xlarge   ProductionVariantInstanceType = "ml.r5d.2xlarge"
	ProductionVariantInstanceTypeMlR5d4xlarge   ProductionVariantInstanceType = "ml.r5d.4xlarge"
	ProductionVariantInstanceTypeMlR5d12xlarge  ProductionVariantInstanceType = "ml.r5d.12xlarge"
	ProductionVariantInstanceTypeMlR5d24xlarge  ProductionVariantInstanceType = "ml.r5d.24xlarge"
	ProductionVariantInstanceTypeMlInf1Xlarge   ProductionVariantInstanceType = "ml.inf1.xlarge"
	ProductionVariantInstanceTypeMlInf12xlarge  ProductionVariantInstanceType = "ml.inf1.2xlarge"
	ProductionVariantInstanceTypeMlInf16xlarge  ProductionVariantInstanceType = "ml.inf1.6xlarge"
	ProductionVariantInstanceTypeMlInf124xlarge ProductionVariantInstanceType = "ml.inf1.24xlarge"
)

func (enum ProductionVariantInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ProductionVariantInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RecordWrapper string

// Enum values for RecordWrapper
const (
	RecordWrapperNone     RecordWrapper = "None"
	RecordWrapperRecordIo RecordWrapper = "RecordIO"
)

func (enum RecordWrapper) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RecordWrapper) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeTrainingJob              ResourceType = "TrainingJob"
	ResourceTypeExperiment               ResourceType = "Experiment"
	ResourceTypeExperimentTrial          ResourceType = "ExperimentTrial"
	ResourceTypeExperimentTrialComponent ResourceType = "ExperimentTrialComponent"
)

func (enum ResourceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ResourceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RetentionType string

// Enum values for RetentionType
const (
	RetentionTypeRetain RetentionType = "Retain"
	RetentionTypeDelete RetentionType = "Delete"
)

func (enum RetentionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RetentionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RootAccess string

// Enum values for RootAccess
const (
	RootAccessEnabled  RootAccess = "Enabled"
	RootAccessDisabled RootAccess = "Disabled"
)

func (enum RootAccess) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RootAccess) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type RuleEvaluationStatus string

// Enum values for RuleEvaluationStatus
const (
	RuleEvaluationStatusInProgress    RuleEvaluationStatus = "InProgress"
	RuleEvaluationStatusNoIssuesFound RuleEvaluationStatus = "NoIssuesFound"
	RuleEvaluationStatusIssuesFound   RuleEvaluationStatus = "IssuesFound"
	RuleEvaluationStatusError         RuleEvaluationStatus = "Error"
	RuleEvaluationStatusStopping      RuleEvaluationStatus = "Stopping"
	RuleEvaluationStatusStopped       RuleEvaluationStatus = "Stopped"
)

func (enum RuleEvaluationStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RuleEvaluationStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type S3DataDistribution string

// Enum values for S3DataDistribution
const (
	S3DataDistributionFullyReplicated S3DataDistribution = "FullyReplicated"
	S3DataDistributionShardedByS3key  S3DataDistribution = "ShardedByS3Key"
)

func (enum S3DataDistribution) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum S3DataDistribution) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type S3DataType string

// Enum values for S3DataType
const (
	S3DataTypeManifestFile          S3DataType = "ManifestFile"
	S3DataTypeS3prefix              S3DataType = "S3Prefix"
	S3DataTypeAugmentedManifestFile S3DataType = "AugmentedManifestFile"
)

func (enum S3DataType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum S3DataType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type ScheduleStatus string

// Enum values for ScheduleStatus
const (
	ScheduleStatusPending   ScheduleStatus = "Pending"
	ScheduleStatusFailed    ScheduleStatus = "Failed"
	ScheduleStatusScheduled ScheduleStatus = "Scheduled"
	ScheduleStatusStopped   ScheduleStatus = "Stopped"
)

func (enum ScheduleStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ScheduleStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SearchSortOrder string

// Enum values for SearchSortOrder
const (
	SearchSortOrderAscending  SearchSortOrder = "Ascending"
	SearchSortOrderDescending SearchSortOrder = "Descending"
)

func (enum SearchSortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SearchSortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SecondaryStatus string

// Enum values for SecondaryStatus
const (
	SecondaryStatusStarting                 SecondaryStatus = "Starting"
	SecondaryStatusLaunchingMlinstances     SecondaryStatus = "LaunchingMLInstances"
	SecondaryStatusPreparingTrainingStack   SecondaryStatus = "PreparingTrainingStack"
	SecondaryStatusDownloading              SecondaryStatus = "Downloading"
	SecondaryStatusDownloadingTrainingImage SecondaryStatus = "DownloadingTrainingImage"
	SecondaryStatusTraining                 SecondaryStatus = "Training"
	SecondaryStatusUploading                SecondaryStatus = "Uploading"
	SecondaryStatusStopping                 SecondaryStatus = "Stopping"
	SecondaryStatusStopped                  SecondaryStatus = "Stopped"
	SecondaryStatusMaxRuntimeExceeded       SecondaryStatus = "MaxRuntimeExceeded"
	SecondaryStatusCompleted                SecondaryStatus = "Completed"
	SecondaryStatusFailed                   SecondaryStatus = "Failed"
	SecondaryStatusInterrupted              SecondaryStatus = "Interrupted"
	SecondaryStatusMaxWaitTimeExceeded      SecondaryStatus = "MaxWaitTimeExceeded"
)

func (enum SecondaryStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SecondaryStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortBy string

// Enum values for SortBy
const (
	SortByName         SortBy = "Name"
	SortByCreationTime SortBy = "CreationTime"
	SortByStatus       SortBy = "Status"
)

func (enum SortBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortExperimentsBy string

// Enum values for SortExperimentsBy
const (
	SortExperimentsByName         SortExperimentsBy = "Name"
	SortExperimentsByCreationTime SortExperimentsBy = "CreationTime"
)

func (enum SortExperimentsBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortExperimentsBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortOrder string

// Enum values for SortOrder
const (
	SortOrderAscending  SortOrder = "Ascending"
	SortOrderDescending SortOrder = "Descending"
)

func (enum SortOrder) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortOrder) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortTrialComponentsBy string

// Enum values for SortTrialComponentsBy
const (
	SortTrialComponentsByName         SortTrialComponentsBy = "Name"
	SortTrialComponentsByCreationTime SortTrialComponentsBy = "CreationTime"
)

func (enum SortTrialComponentsBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortTrialComponentsBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SortTrialsBy string

// Enum values for SortTrialsBy
const (
	SortTrialsByName         SortTrialsBy = "Name"
	SortTrialsByCreationTime SortTrialsBy = "CreationTime"
)

func (enum SortTrialsBy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SortTrialsBy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type SplitType string

// Enum values for SplitType
const (
	SplitTypeNone     SplitType = "None"
	SplitTypeLine     SplitType = "Line"
	SplitTypeRecordIo SplitType = "RecordIO"
	SplitTypeTfrecord SplitType = "TFRecord"
)

func (enum SplitType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SplitType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TargetDevice string

// Enum values for TargetDevice
const (
	TargetDeviceLambda     TargetDevice = "lambda"
	TargetDeviceMlM4       TargetDevice = "ml_m4"
	TargetDeviceMlM5       TargetDevice = "ml_m5"
	TargetDeviceMlC4       TargetDevice = "ml_c4"
	TargetDeviceMlC5       TargetDevice = "ml_c5"
	TargetDeviceMlP2       TargetDevice = "ml_p2"
	TargetDeviceMlP3       TargetDevice = "ml_p3"
	TargetDeviceMlInf1     TargetDevice = "ml_inf1"
	TargetDeviceJetsonTx1  TargetDevice = "jetson_tx1"
	TargetDeviceJetsonTx2  TargetDevice = "jetson_tx2"
	TargetDeviceJetsonNano TargetDevice = "jetson_nano"
	TargetDeviceRasp3b     TargetDevice = "rasp3b"
	TargetDeviceDeeplens   TargetDevice = "deeplens"
	TargetDeviceRk3399     TargetDevice = "rk3399"
	TargetDeviceRk3288     TargetDevice = "rk3288"
	TargetDeviceAisage     TargetDevice = "aisage"
	TargetDeviceSbeC       TargetDevice = "sbe_c"
	TargetDeviceQcs605     TargetDevice = "qcs605"
	TargetDeviceQcs603     TargetDevice = "qcs603"
)

func (enum TargetDevice) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TargetDevice) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingInputMode string

// Enum values for TrainingInputMode
const (
	TrainingInputModePipe TrainingInputMode = "Pipe"
	TrainingInputModeFile TrainingInputMode = "File"
)

func (enum TrainingInputMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingInputMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingInstanceType string

// Enum values for TrainingInstanceType
const (
	TrainingInstanceTypeMlM4Xlarge     TrainingInstanceType = "ml.m4.xlarge"
	TrainingInstanceTypeMlM42xlarge    TrainingInstanceType = "ml.m4.2xlarge"
	TrainingInstanceTypeMlM44xlarge    TrainingInstanceType = "ml.m4.4xlarge"
	TrainingInstanceTypeMlM410xlarge   TrainingInstanceType = "ml.m4.10xlarge"
	TrainingInstanceTypeMlM416xlarge   TrainingInstanceType = "ml.m4.16xlarge"
	TrainingInstanceTypeMlM5Large      TrainingInstanceType = "ml.m5.large"
	TrainingInstanceTypeMlM5Xlarge     TrainingInstanceType = "ml.m5.xlarge"
	TrainingInstanceTypeMlM52xlarge    TrainingInstanceType = "ml.m5.2xlarge"
	TrainingInstanceTypeMlM54xlarge    TrainingInstanceType = "ml.m5.4xlarge"
	TrainingInstanceTypeMlM512xlarge   TrainingInstanceType = "ml.m5.12xlarge"
	TrainingInstanceTypeMlM524xlarge   TrainingInstanceType = "ml.m5.24xlarge"
	TrainingInstanceTypeMlC4Xlarge     TrainingInstanceType = "ml.c4.xlarge"
	TrainingInstanceTypeMlC42xlarge    TrainingInstanceType = "ml.c4.2xlarge"
	TrainingInstanceTypeMlC44xlarge    TrainingInstanceType = "ml.c4.4xlarge"
	TrainingInstanceTypeMlC48xlarge    TrainingInstanceType = "ml.c4.8xlarge"
	TrainingInstanceTypeMlP2Xlarge     TrainingInstanceType = "ml.p2.xlarge"
	TrainingInstanceTypeMlP28xlarge    TrainingInstanceType = "ml.p2.8xlarge"
	TrainingInstanceTypeMlP216xlarge   TrainingInstanceType = "ml.p2.16xlarge"
	TrainingInstanceTypeMlP32xlarge    TrainingInstanceType = "ml.p3.2xlarge"
	TrainingInstanceTypeMlP38xlarge    TrainingInstanceType = "ml.p3.8xlarge"
	TrainingInstanceTypeMlP316xlarge   TrainingInstanceType = "ml.p3.16xlarge"
	TrainingInstanceTypeMlP3dn24xlarge TrainingInstanceType = "ml.p3dn.24xlarge"
	TrainingInstanceTypeMlC5Xlarge     TrainingInstanceType = "ml.c5.xlarge"
	TrainingInstanceTypeMlC52xlarge    TrainingInstanceType = "ml.c5.2xlarge"
	TrainingInstanceTypeMlC54xlarge    TrainingInstanceType = "ml.c5.4xlarge"
	TrainingInstanceTypeMlC59xlarge    TrainingInstanceType = "ml.c5.9xlarge"
	TrainingInstanceTypeMlC518xlarge   TrainingInstanceType = "ml.c5.18xlarge"
)

func (enum TrainingInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingJobEarlyStoppingType string

// Enum values for TrainingJobEarlyStoppingType
const (
	TrainingJobEarlyStoppingTypeOff  TrainingJobEarlyStoppingType = "Off"
	TrainingJobEarlyStoppingTypeAuto TrainingJobEarlyStoppingType = "Auto"
)

func (enum TrainingJobEarlyStoppingType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingJobEarlyStoppingType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingJobSortByOptions string

// Enum values for TrainingJobSortByOptions
const (
	TrainingJobSortByOptionsName                      TrainingJobSortByOptions = "Name"
	TrainingJobSortByOptionsCreationTime              TrainingJobSortByOptions = "CreationTime"
	TrainingJobSortByOptionsStatus                    TrainingJobSortByOptions = "Status"
	TrainingJobSortByOptionsFinalObjectiveMetricValue TrainingJobSortByOptions = "FinalObjectiveMetricValue"
)

func (enum TrainingJobSortByOptions) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingJobSortByOptions) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrainingJobStatus string

// Enum values for TrainingJobStatus
const (
	TrainingJobStatusInProgress TrainingJobStatus = "InProgress"
	TrainingJobStatusCompleted  TrainingJobStatus = "Completed"
	TrainingJobStatusFailed     TrainingJobStatus = "Failed"
	TrainingJobStatusStopping   TrainingJobStatus = "Stopping"
	TrainingJobStatusStopped    TrainingJobStatus = "Stopped"
)

func (enum TrainingJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrainingJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TransformInstanceType string

// Enum values for TransformInstanceType
const (
	TransformInstanceTypeMlM4Xlarge   TransformInstanceType = "ml.m4.xlarge"
	TransformInstanceTypeMlM42xlarge  TransformInstanceType = "ml.m4.2xlarge"
	TransformInstanceTypeMlM44xlarge  TransformInstanceType = "ml.m4.4xlarge"
	TransformInstanceTypeMlM410xlarge TransformInstanceType = "ml.m4.10xlarge"
	TransformInstanceTypeMlM416xlarge TransformInstanceType = "ml.m4.16xlarge"
	TransformInstanceTypeMlC4Xlarge   TransformInstanceType = "ml.c4.xlarge"
	TransformInstanceTypeMlC42xlarge  TransformInstanceType = "ml.c4.2xlarge"
	TransformInstanceTypeMlC44xlarge  TransformInstanceType = "ml.c4.4xlarge"
	TransformInstanceTypeMlC48xlarge  TransformInstanceType = "ml.c4.8xlarge"
	TransformInstanceTypeMlP2Xlarge   TransformInstanceType = "ml.p2.xlarge"
	TransformInstanceTypeMlP28xlarge  TransformInstanceType = "ml.p2.8xlarge"
	TransformInstanceTypeMlP216xlarge TransformInstanceType = "ml.p2.16xlarge"
	TransformInstanceTypeMlP32xlarge  TransformInstanceType = "ml.p3.2xlarge"
	TransformInstanceTypeMlP38xlarge  TransformInstanceType = "ml.p3.8xlarge"
	TransformInstanceTypeMlP316xlarge TransformInstanceType = "ml.p3.16xlarge"
	TransformInstanceTypeMlC5Xlarge   TransformInstanceType = "ml.c5.xlarge"
	TransformInstanceTypeMlC52xlarge  TransformInstanceType = "ml.c5.2xlarge"
	TransformInstanceTypeMlC54xlarge  TransformInstanceType = "ml.c5.4xlarge"
	TransformInstanceTypeMlC59xlarge  TransformInstanceType = "ml.c5.9xlarge"
	TransformInstanceTypeMlC518xlarge TransformInstanceType = "ml.c5.18xlarge"
	TransformInstanceTypeMlM5Large    TransformInstanceType = "ml.m5.large"
	TransformInstanceTypeMlM5Xlarge   TransformInstanceType = "ml.m5.xlarge"
	TransformInstanceTypeMlM52xlarge  TransformInstanceType = "ml.m5.2xlarge"
	TransformInstanceTypeMlM54xlarge  TransformInstanceType = "ml.m5.4xlarge"
	TransformInstanceTypeMlM512xlarge TransformInstanceType = "ml.m5.12xlarge"
	TransformInstanceTypeMlM524xlarge TransformInstanceType = "ml.m5.24xlarge"
)

func (enum TransformInstanceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TransformInstanceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TransformJobStatus string

// Enum values for TransformJobStatus
const (
	TransformJobStatusInProgress TransformJobStatus = "InProgress"
	TransformJobStatusCompleted  TransformJobStatus = "Completed"
	TransformJobStatusFailed     TransformJobStatus = "Failed"
	TransformJobStatusStopping   TransformJobStatus = "Stopping"
	TransformJobStatusStopped    TransformJobStatus = "Stopped"
)

func (enum TransformJobStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TransformJobStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type TrialComponentPrimaryStatus string

// Enum values for TrialComponentPrimaryStatus
const (
	TrialComponentPrimaryStatusInProgress TrialComponentPrimaryStatus = "InProgress"
	TrialComponentPrimaryStatusCompleted  TrialComponentPrimaryStatus = "Completed"
	TrialComponentPrimaryStatusFailed     TrialComponentPrimaryStatus = "Failed"
)

func (enum TrialComponentPrimaryStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TrialComponentPrimaryStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type UserProfileSortKey string

// Enum values for UserProfileSortKey
const (
	UserProfileSortKeyCreationTime     UserProfileSortKey = "CreationTime"
	UserProfileSortKeyLastModifiedTime UserProfileSortKey = "LastModifiedTime"
)

func (enum UserProfileSortKey) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum UserProfileSortKey) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type UserProfileStatus string

// Enum values for UserProfileStatus
const (
	UserProfileStatusDeleting  UserProfileStatus = "Deleting"
	UserProfileStatusFailed    UserProfileStatus = "Failed"
	UserProfileStatusInService UserProfileStatus = "InService"
	UserProfileStatusPending   UserProfileStatus = "Pending"
)

func (enum UserProfileStatus) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum UserProfileStatus) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}
