// 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 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 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 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 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 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 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 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 NotebookInstanceAcceleratorType string

// Enum values for NotebookInstanceAcceleratorType
const (
	NotebookInstanceAcceleratorTypeMlEia1Medium NotebookInstanceAcceleratorType = "ml.eia1.medium"
	NotebookInstanceAcceleratorTypeMlEia1Large  NotebookInstanceAcceleratorType = "ml.eia1.large"
	NotebookInstanceAcceleratorTypeMlEia1Xlarge NotebookInstanceAcceleratorType = "ml.eia1.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 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"
)

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 ProductionVariantAcceleratorType string

// Enum values for ProductionVariantAcceleratorType
const (
	ProductionVariantAcceleratorTypeMlEia1Medium ProductionVariantAcceleratorType = "ml.eia1.medium"
	ProductionVariantAcceleratorTypeMlEia1Large  ProductionVariantAcceleratorType = "ml.eia1.large"
	ProductionVariantAcceleratorTypeMlEia1Xlarge ProductionVariantAcceleratorType = "ml.eia1.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"
	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"
)

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"
)

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 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 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 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"
)

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 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 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"
	TargetDeviceJetsonTx1  TargetDevice = "jetson_tx1"
	TargetDeviceJetsonTx2  TargetDevice = "jetson_tx2"
	TargetDeviceJetsonNano TargetDevice = "jetson_nano"
	TargetDeviceRasp3b     TargetDevice = "rasp3b"
	TargetDeviceDeeplens   TargetDevice = "deeplens"
	TargetDeviceRk3399     TargetDevice = "rk3399"
	TargetDeviceRk3288     TargetDevice = "rk3288"
)

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"
	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
}
