api_enums.go

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

package s3

type AnalyticsS3ExportFileFormat string

// Enum values for AnalyticsS3ExportFileFormat
const (
	AnalyticsS3ExportFileFormatCsv AnalyticsS3ExportFileFormat = "CSV"
)

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

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

type BucketAccelerateStatus string

// Enum values for BucketAccelerateStatus
const (
	BucketAccelerateStatusEnabled   BucketAccelerateStatus = "Enabled"
	BucketAccelerateStatusSuspended BucketAccelerateStatus = "Suspended"
)

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

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

type BucketCannedACL string

// Enum values for BucketCannedACL
const (
	BucketCannedACLPrivate           BucketCannedACL = "private"
	BucketCannedACLPublicRead        BucketCannedACL = "public-read"
	BucketCannedACLPublicReadWrite   BucketCannedACL = "public-read-write"
	BucketCannedACLAuthenticatedRead BucketCannedACL = "authenticated-read"
)

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

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

type BucketLocationConstraint string

// Enum values for BucketLocationConstraint
const (
	BucketLocationConstraintEu           BucketLocationConstraint = "EU"
	BucketLocationConstraintEuWest1      BucketLocationConstraint = "eu-west-1"
	BucketLocationConstraintUsWest1      BucketLocationConstraint = "us-west-1"
	BucketLocationConstraintUsWest2      BucketLocationConstraint = "us-west-2"
	BucketLocationConstraintApSouth1     BucketLocationConstraint = "ap-south-1"
	BucketLocationConstraintApSoutheast1 BucketLocationConstraint = "ap-southeast-1"
	BucketLocationConstraintApSoutheast2 BucketLocationConstraint = "ap-southeast-2"
	BucketLocationConstraintApNortheast1 BucketLocationConstraint = "ap-northeast-1"
	BucketLocationConstraintSaEast1      BucketLocationConstraint = "sa-east-1"
	BucketLocationConstraintCnNorth1     BucketLocationConstraint = "cn-north-1"
	BucketLocationConstraintEuCentral1   BucketLocationConstraint = "eu-central-1"
)

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

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

type BucketLogsPermission string

// Enum values for BucketLogsPermission
const (
	BucketLogsPermissionFullControl BucketLogsPermission = "FULL_CONTROL"
	BucketLogsPermissionRead        BucketLogsPermission = "READ"
	BucketLogsPermissionWrite       BucketLogsPermission = "WRITE"
)

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

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

type BucketVersioningStatus string

// Enum values for BucketVersioningStatus
const (
	BucketVersioningStatusEnabled   BucketVersioningStatus = "Enabled"
	BucketVersioningStatusSuspended BucketVersioningStatus = "Suspended"
)

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

func (enum BucketVersioningStatus) 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"
	CompressionTypeBzip2 CompressionType = "BZIP2"
)

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

// Enum values for DeleteMarkerReplicationStatus
const (
	DeleteMarkerReplicationStatusEnabled  DeleteMarkerReplicationStatus = "Enabled"
	DeleteMarkerReplicationStatusDisabled DeleteMarkerReplicationStatus = "Disabled"
)

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

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

// Requests Amazon S3 to encode the object keys in the response and specifies
// the encoding method to use. An object key may contain any Unicode character;
// however, XML 1.0 parser cannot parse some characters, such as characters
// with an ASCII value from 0 to 10. For characters that are not supported in
// XML 1.0, you can add this parameter to request that Amazon S3 encode the
// keys in the response.
type EncodingType string

// Enum values for EncodingType
const (
	EncodingTypeUrl EncodingType = "url"
)

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

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

// The bucket event for which to send notifications.
type Event string

// Enum values for Event
const (
	EventS3ReducedRedundancyLostObject                  Event = "s3:ReducedRedundancyLostObject"
	EventS3ObjectCreated                                Event = "s3:ObjectCreated:*"
	EventS3ObjectCreatedPut                             Event = "s3:ObjectCreated:Put"
	EventS3ObjectCreatedPost                            Event = "s3:ObjectCreated:Post"
	EventS3ObjectCreatedCopy                            Event = "s3:ObjectCreated:Copy"
	EventS3ObjectCreatedCompleteMultipartUpload         Event = "s3:ObjectCreated:CompleteMultipartUpload"
	EventS3ObjectRemoved                                Event = "s3:ObjectRemoved:*"
	EventS3ObjectRemovedDelete                          Event = "s3:ObjectRemoved:Delete"
	EventS3ObjectRemovedDeleteMarkerCreated             Event = "s3:ObjectRemoved:DeleteMarkerCreated"
	EventS3ObjectRestore                                Event = "s3:ObjectRestore:*"
	EventS3ObjectRestorePost                            Event = "s3:ObjectRestore:Post"
	EventS3ObjectRestoreCompleted                       Event = "s3:ObjectRestore:Completed"
	EventS3Replication                                  Event = "s3:Replication:*"
	EventS3ReplicationOperationFailedReplication        Event = "s3:Replication:OperationFailedReplication"
	EventS3ReplicationOperationNotTracked               Event = "s3:Replication:OperationNotTracked"
	EventS3ReplicationOperationMissedThreshold          Event = "s3:Replication:OperationMissedThreshold"
	EventS3ReplicationOperationReplicatedAfterThreshold Event = "s3:Replication:OperationReplicatedAfterThreshold"
)

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

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

type ExistingObjectReplicationStatus string

// Enum values for ExistingObjectReplicationStatus
const (
	ExistingObjectReplicationStatusEnabled  ExistingObjectReplicationStatus = "Enabled"
	ExistingObjectReplicationStatusDisabled ExistingObjectReplicationStatus = "Disabled"
)

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

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

type ExpirationStatus string

// Enum values for ExpirationStatus
const (
	ExpirationStatusEnabled  ExpirationStatus = "Enabled"
	ExpirationStatusDisabled ExpirationStatus = "Disabled"
)

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

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

type ExpressionType string

// Enum values for ExpressionType
const (
	ExpressionTypeSql ExpressionType = "SQL"
)

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

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

type FileHeaderInfo string

// Enum values for FileHeaderInfo
const (
	FileHeaderInfoUse    FileHeaderInfo = "USE"
	FileHeaderInfoIgnore FileHeaderInfo = "IGNORE"
	FileHeaderInfoNone   FileHeaderInfo = "NONE"
)

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

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

type FilterRuleName string

// Enum values for FilterRuleName
const (
	FilterRuleNamePrefix FilterRuleName = "prefix"
	FilterRuleNameSuffix FilterRuleName = "suffix"
)

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

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

type InventoryFormat string

// Enum values for InventoryFormat
const (
	InventoryFormatCsv     InventoryFormat = "CSV"
	InventoryFormatOrc     InventoryFormat = "ORC"
	InventoryFormatParquet InventoryFormat = "Parquet"
)

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

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

type InventoryFrequency string

// Enum values for InventoryFrequency
const (
	InventoryFrequencyDaily  InventoryFrequency = "Daily"
	InventoryFrequencyWeekly InventoryFrequency = "Weekly"
)

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

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

type InventoryIncludedObjectVersions string

// Enum values for InventoryIncludedObjectVersions
const (
	InventoryIncludedObjectVersionsAll     InventoryIncludedObjectVersions = "All"
	InventoryIncludedObjectVersionsCurrent InventoryIncludedObjectVersions = "Current"
)

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

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

type InventoryOptionalField string

// Enum values for InventoryOptionalField
const (
	InventoryOptionalFieldSize                         InventoryOptionalField = "Size"
	InventoryOptionalFieldLastModifiedDate             InventoryOptionalField = "LastModifiedDate"
	InventoryOptionalFieldStorageClass                 InventoryOptionalField = "StorageClass"
	InventoryOptionalFieldEtag                         InventoryOptionalField = "ETag"
	InventoryOptionalFieldIsMultipartUploaded          InventoryOptionalField = "IsMultipartUploaded"
	InventoryOptionalFieldReplicationStatus            InventoryOptionalField = "ReplicationStatus"
	InventoryOptionalFieldEncryptionStatus             InventoryOptionalField = "EncryptionStatus"
	InventoryOptionalFieldObjectLockRetainUntilDate    InventoryOptionalField = "ObjectLockRetainUntilDate"
	InventoryOptionalFieldObjectLockMode               InventoryOptionalField = "ObjectLockMode"
	InventoryOptionalFieldObjectLockLegalHoldStatus    InventoryOptionalField = "ObjectLockLegalHoldStatus"
	InventoryOptionalFieldIntelligentTieringAccessTier InventoryOptionalField = "IntelligentTieringAccessTier"
)

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

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

type JSONType string

// Enum values for JSONType
const (
	JSONTypeDocument JSONType = "DOCUMENT"
	JSONTypeLines    JSONType = "LINES"
)

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

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

type MFADelete string

// Enum values for MFADelete
const (
	MFADeleteEnabled  MFADelete = "Enabled"
	MFADeleteDisabled MFADelete = "Disabled"
)

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

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

type MFADeleteStatus string

// Enum values for MFADeleteStatus
const (
	MFADeleteStatusEnabled  MFADeleteStatus = "Enabled"
	MFADeleteStatusDisabled MFADeleteStatus = "Disabled"
)

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

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

type MetadataDirective string

// Enum values for MetadataDirective
const (
	MetadataDirectiveCopy    MetadataDirective = "COPY"
	MetadataDirectiveReplace MetadataDirective = "REPLACE"
)

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

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

type MetricsStatus string

// Enum values for MetricsStatus
const (
	MetricsStatusEnabled  MetricsStatus = "Enabled"
	MetricsStatusDisabled MetricsStatus = "Disabled"
)

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

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

type ObjectCannedACL string

// Enum values for ObjectCannedACL
const (
	ObjectCannedACLPrivate                ObjectCannedACL = "private"
	ObjectCannedACLPublicRead             ObjectCannedACL = "public-read"
	ObjectCannedACLPublicReadWrite        ObjectCannedACL = "public-read-write"
	ObjectCannedACLAuthenticatedRead      ObjectCannedACL = "authenticated-read"
	ObjectCannedACLAwsExecRead            ObjectCannedACL = "aws-exec-read"
	ObjectCannedACLBucketOwnerRead        ObjectCannedACL = "bucket-owner-read"
	ObjectCannedACLBucketOwnerFullControl ObjectCannedACL = "bucket-owner-full-control"
)

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

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

type ObjectLockEnabled string

// Enum values for ObjectLockEnabled
const (
	ObjectLockEnabledEnabled ObjectLockEnabled = "Enabled"
)

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

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

type ObjectLockLegalHoldStatus string

// Enum values for ObjectLockLegalHoldStatus
const (
	ObjectLockLegalHoldStatusOn  ObjectLockLegalHoldStatus = "ON"
	ObjectLockLegalHoldStatusOff ObjectLockLegalHoldStatus = "OFF"
)

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

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

type ObjectLockMode string

// Enum values for ObjectLockMode
const (
	ObjectLockModeGovernance ObjectLockMode = "GOVERNANCE"
	ObjectLockModeCompliance ObjectLockMode = "COMPLIANCE"
)

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

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

type ObjectLockRetentionMode string

// Enum values for ObjectLockRetentionMode
const (
	ObjectLockRetentionModeGovernance ObjectLockRetentionMode = "GOVERNANCE"
	ObjectLockRetentionModeCompliance ObjectLockRetentionMode = "COMPLIANCE"
)

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

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

type ObjectStorageClass string

// Enum values for ObjectStorageClass
const (
	ObjectStorageClassStandard           ObjectStorageClass = "STANDARD"
	ObjectStorageClassReducedRedundancy  ObjectStorageClass = "REDUCED_REDUNDANCY"
	ObjectStorageClassGlacier            ObjectStorageClass = "GLACIER"
	ObjectStorageClassStandardIa         ObjectStorageClass = "STANDARD_IA"
	ObjectStorageClassOnezoneIa          ObjectStorageClass = "ONEZONE_IA"
	ObjectStorageClassIntelligentTiering ObjectStorageClass = "INTELLIGENT_TIERING"
	ObjectStorageClassDeepArchive        ObjectStorageClass = "DEEP_ARCHIVE"
)

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

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

type ObjectVersionStorageClass string

// Enum values for ObjectVersionStorageClass
const (
	ObjectVersionStorageClassStandard ObjectVersionStorageClass = "STANDARD"
)

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

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

type OwnerOverride string

// Enum values for OwnerOverride
const (
	OwnerOverrideDestination OwnerOverride = "Destination"
)

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

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

type Payer string

// Enum values for Payer
const (
	PayerRequester   Payer = "Requester"
	PayerBucketOwner Payer = "BucketOwner"
)

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

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

type Permission string

// Enum values for Permission
const (
	PermissionFullControl Permission = "FULL_CONTROL"
	PermissionWrite       Permission = "WRITE"
	PermissionWriteAcp    Permission = "WRITE_ACP"
	PermissionRead        Permission = "READ"
	PermissionReadAcp     Permission = "READ_ACP"
)

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

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

type Protocol string

// Enum values for Protocol
const (
	ProtocolHttp  Protocol = "http"
	ProtocolHttps Protocol = "https"
)

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

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

type QuoteFields string

// Enum values for QuoteFields
const (
	QuoteFieldsAlways   QuoteFields = "ALWAYS"
	QuoteFieldsAsneeded QuoteFields = "ASNEEDED"
)

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

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

type ReplicationRuleStatus string

// Enum values for ReplicationRuleStatus
const (
	ReplicationRuleStatusEnabled  ReplicationRuleStatus = "Enabled"
	ReplicationRuleStatusDisabled ReplicationRuleStatus = "Disabled"
)

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

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

type ReplicationStatus string

// Enum values for ReplicationStatus
const (
	ReplicationStatusComplete ReplicationStatus = "COMPLETE"
	ReplicationStatusPending  ReplicationStatus = "PENDING"
	ReplicationStatusFailed   ReplicationStatus = "FAILED"
	ReplicationStatusReplica  ReplicationStatus = "REPLICA"
)

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

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

type ReplicationTimeStatus string

// Enum values for ReplicationTimeStatus
const (
	ReplicationTimeStatusEnabled  ReplicationTimeStatus = "Enabled"
	ReplicationTimeStatusDisabled ReplicationTimeStatus = "Disabled"
)

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

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

// If present, indicates that the requester was successfully charged for the
// request.
type RequestCharged string

// Enum values for RequestCharged
const (
	RequestChargedRequester RequestCharged = "requester"
)

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

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

// Confirms that the requester knows that they will be charged for the request.
// Bucket owners need not specify this parameter in their requests. For information
// about downloading objects from requester pays buckets, see Downloading Objects
// in Requestor Pays Buckets (https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html)
// in the Amazon S3 Developer Guide.
type RequestPayer string

// Enum values for RequestPayer
const (
	RequestPayerRequester RequestPayer = "requester"
)

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

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

type RestoreRequestType string

// Enum values for RestoreRequestType
const (
	RestoreRequestTypeSelect RestoreRequestType = "SELECT"
)

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

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

type ServerSideEncryption string

// Enum values for ServerSideEncryption
const (
	ServerSideEncryptionAes256 ServerSideEncryption = "AES256"
	ServerSideEncryptionAwsKms ServerSideEncryption = "aws:kms"
)

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

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

type SseKmsEncryptedObjectsStatus string

// Enum values for SseKmsEncryptedObjectsStatus
const (
	SseKmsEncryptedObjectsStatusEnabled  SseKmsEncryptedObjectsStatus = "Enabled"
	SseKmsEncryptedObjectsStatusDisabled SseKmsEncryptedObjectsStatus = "Disabled"
)

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

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

type StorageClass string

// Enum values for StorageClass
const (
	StorageClassStandard           StorageClass = "STANDARD"
	StorageClassReducedRedundancy  StorageClass = "REDUCED_REDUNDANCY"
	StorageClassStandardIa         StorageClass = "STANDARD_IA"
	StorageClassOnezoneIa          StorageClass = "ONEZONE_IA"
	StorageClassIntelligentTiering StorageClass = "INTELLIGENT_TIERING"
	StorageClassGlacier            StorageClass = "GLACIER"
	StorageClassDeepArchive        StorageClass = "DEEP_ARCHIVE"
)

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

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

type StorageClassAnalysisSchemaVersion string

// Enum values for StorageClassAnalysisSchemaVersion
const (
	StorageClassAnalysisSchemaVersionV1 StorageClassAnalysisSchemaVersion = "V_1"
)

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

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

type TaggingDirective string

// Enum values for TaggingDirective
const (
	TaggingDirectiveCopy    TaggingDirective = "COPY"
	TaggingDirectiveReplace TaggingDirective = "REPLACE"
)

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

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

type Tier string

// Enum values for Tier
const (
	TierStandard  Tier = "Standard"
	TierBulk      Tier = "Bulk"
	TierExpedited Tier = "Expedited"
)

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

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

type TransitionStorageClass string

// Enum values for TransitionStorageClass
const (
	TransitionStorageClassGlacier            TransitionStorageClass = "GLACIER"
	TransitionStorageClassStandardIa         TransitionStorageClass = "STANDARD_IA"
	TransitionStorageClassOnezoneIa          TransitionStorageClass = "ONEZONE_IA"
	TransitionStorageClassIntelligentTiering TransitionStorageClass = "INTELLIGENT_TIERING"
	TransitionStorageClassDeepArchive        TransitionStorageClass = "DEEP_ARCHIVE"
)

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

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

type Type string

// Enum values for Type
const (
	TypeCanonicalUser         Type = "CanonicalUser"
	TypeAmazonCustomerByEmail Type = "AmazonCustomerByEmail"
	TypeGroup                 Type = "Group"
)

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

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