s3/types/types.go

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

package types

import (
	"time"
)

// Specifies the days since the initiation of an incomplete multipart upload that
// Amazon S3 will wait before permanently removing all parts of the upload. For
// more information, see  Aborting Incomplete Multipart Uploads Using a Bucket
// Lifecycle Policy
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config)
// in the Amazon Simple Storage Service Developer Guide.
type AbortIncompleteMultipartUpload struct {

	// Specifies the number of days after which Amazon S3 aborts an incomplete
	// multipart upload.
	DaysAfterInitiation int32
}

// Configures the transfer acceleration state for an Amazon S3 bucket. For more
// information, see Amazon S3 Transfer Acceleration
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html) in
// the Amazon Simple Storage Service Developer Guide.
type AccelerateConfiguration struct {

	// Specifies the transfer acceleration status of the bucket.
	Status BucketAccelerateStatus
}

// Contains the elements that set the ACL permissions for an object per grantee.
type AccessControlPolicy struct {

	// A list of grants.
	Grants []Grant

	// Container for the bucket owner's display name and ID.
	Owner *Owner
}

// A container for information about access control for replicas.
type AccessControlTranslation struct {

	// Specifies the replica ownership. For default and valid values, see PUT bucket
	// replication
	// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html)
	// in the Amazon Simple Storage Service API Reference.
	//
	// This member is required.
	Owner OwnerOverride
}

// A conjunction (logical AND) of predicates, which is used in evaluating a metrics
// filter. The operator must have at least two predicates in any combination, and
// an object must match all of the predicates for the filter to apply.
type AnalyticsAndOperator struct {

	// The prefix to use when evaluating an AND predicate: The prefix that an object
	// must have to be included in the metrics results.
	Prefix *string

	// The list of tags to use when evaluating an AND predicate.
	Tags []Tag
}

// Specifies the configuration and any analyses for the analytics filter of an
// Amazon S3 bucket.
type AnalyticsConfiguration struct {

	// The ID that identifies the analytics configuration.
	//
	// This member is required.
	Id *string

	// Contains data related to access patterns to be collected and made available to
	// analyze the tradeoffs between different storage classes.
	//
	// This member is required.
	StorageClassAnalysis *StorageClassAnalysis

	// The filter used to describe a set of objects for analyses. A filter must have
	// exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator). If no
	// filter is provided, all objects will be considered in any analysis.
	Filter AnalyticsFilter
}

// Where to publish the analytics results.
type AnalyticsExportDestination struct {

	// A destination signifying output to an S3 bucket.
	//
	// This member is required.
	S3BucketDestination *AnalyticsS3BucketDestination
}

// The filter used to describe a set of objects for analyses. A filter must have
// exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator). If no
// filter is provided, all objects will be considered in any analysis.
//
// The following types satisfy this interface:
//  AnalyticsFilterMemberPrefix
//  AnalyticsFilterMemberTag
//  AnalyticsFilterMemberAnd
type AnalyticsFilter interface {
	isAnalyticsFilter()
}

// The prefix to use when evaluating an analytics filter.
type AnalyticsFilterMemberPrefix struct {
	Value string
}

func (*AnalyticsFilterMemberPrefix) isAnalyticsFilter() {}

// The tag to use when evaluating an analytics filter.
type AnalyticsFilterMemberTag struct {
	Value Tag
}

func (*AnalyticsFilterMemberTag) isAnalyticsFilter() {}

// A conjunction (logical AND) of predicates, which is used in evaluating an
// analytics filter. The operator must have at least two predicates.
type AnalyticsFilterMemberAnd struct {
	Value AnalyticsAndOperator
}

func (*AnalyticsFilterMemberAnd) isAnalyticsFilter() {}

// Contains information about where to publish the analytics results.
type AnalyticsS3BucketDestination struct {

	// The Amazon Resource Name (ARN) of the bucket to which data is exported.
	//
	// This member is required.
	Bucket *string

	// Specifies the file format used when exporting data to Amazon S3.
	//
	// This member is required.
	Format AnalyticsS3ExportFileFormat

	// The account ID that owns the destination S3 bucket. If no account ID is
	// provided, the owner is not validated before exporting data. Although this value
	// is optional, we strongly recommend that you set it to help prevent problems if
	// the destination bucket ownership changes.
	BucketAccountId *string

	// The prefix to use when exporting data. The prefix is prepended to all results.
	Prefix *string
}

// In terms of implementation, a Bucket is a resource. An Amazon S3 bucket name is
// globally unique, and the namespace is shared by all AWS accounts.
type Bucket struct {

	// Date the bucket was created. This date can change when making changes to your
	// bucket, such as editing its bucket policy.
	CreationDate *time.Time

	// The name of the bucket.
	Name *string
}

// Specifies the lifecycle configuration for objects in an Amazon S3 bucket. For
// more information, see Object Lifecycle Management
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html) in
// the Amazon Simple Storage Service Developer Guide.
type BucketLifecycleConfiguration struct {

	// A lifecycle rule for individual objects in an Amazon S3 bucket.
	//
	// This member is required.
	Rules []LifecycleRule
}

// Container for logging status information.
type BucketLoggingStatus struct {

	// Describes where logs are stored and the prefix that Amazon S3 assigns to all log
	// object keys for a bucket. For more information, see PUT Bucket logging
	// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html) in
	// the Amazon Simple Storage Service API Reference.
	LoggingEnabled *LoggingEnabled
}

// Container for all (if there are any) keys between Prefix and the next occurrence
// of the string specified by a delimiter. CommonPrefixes lists keys that act like
// subdirectories in the directory specified by Prefix. For example, if the prefix
// is notes/ and the delimiter is a slash (/) as in notes/summer/july, the common
// prefix is notes/summer/.
type CommonPrefix struct {

	// Container for the specified common prefix.
	Prefix *string
}

// The container for the completed multipart upload details.
type CompletedMultipartUpload struct {

	// Array of CompletedPart data types.
	Parts []CompletedPart
}

// Details of the parts that were uploaded.
type CompletedPart struct {

	// Entity tag returned when the part was uploaded.
	ETag *string

	// Part number that identifies the part. This is a positive integer between 1 and
	// 10,000.
	PartNumber int32
}

// A container for describing a condition that must be met for the specified
// redirect to apply. For example, 1. If request is for pages in the /docs folder,
// redirect to the /documents folder. 2. If request results in HTTP error 4xx,
// redirect request to another host where you might process the error.
type Condition struct {

	// The HTTP error code when the redirect is applied. In the event of an error, if
	// the error code equals this value, then the specified redirect is applied.
	// Required when parent element Condition is specified and sibling KeyPrefixEquals
	// is not specified. If both are specified, then both must be true for the redirect
	// to be applied.
	HttpErrorCodeReturnedEquals *string

	// The object key name prefix when the redirect is applied. For example, to
	// redirect requests for ExamplePage.html, the key prefix will be ExamplePage.html.
	// To redirect request for all pages with the prefix docs/, the key prefix will be
	// /docs, which identifies all objects in the docs/ folder. Required when the
	// parent element Condition is specified and sibling HttpErrorCodeReturnedEquals is
	// not specified. If both conditions are specified, both must be true for the
	// redirect to be applied.
	KeyPrefixEquals *string
}

// Container for all response elements.
type CopyObjectResult struct {

	// Returns the ETag of the new object. The ETag reflects only changes to the
	// contents of an object, not its metadata. The source and destination ETag is
	// identical for a successfully copied object.
	ETag *string

	// Returns the date that the object was last modified.
	LastModified *time.Time
}

// Container for all response elements.
type CopyPartResult struct {

	// Entity tag of the object.
	ETag *string

	// Date and time at which the object was uploaded.
	LastModified *time.Time
}

// Describes the cross-origin access configuration for objects in an Amazon S3
// bucket. For more information, see Enabling Cross-Origin Resource Sharing
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html) in the Amazon Simple
// Storage Service Developer Guide.
type CORSConfiguration struct {

	// A set of origins and methods (cross-origin access that you want to allow). You
	// can add up to 100 rules to the configuration.
	//
	// This member is required.
	CORSRules []CORSRule
}

// Specifies a cross-origin access rule for an Amazon S3 bucket.
type CORSRule struct {

	// An HTTP method that you allow the origin to execute. Valid values are GET, PUT,
	// HEAD, POST, and DELETE.
	//
	// This member is required.
	AllowedMethods []string

	// One or more origins you want customers to be able to access the bucket from.
	//
	// This member is required.
	AllowedOrigins []string

	// Headers that are specified in the Access-Control-Request-Headers header. These
	// headers are allowed in a preflight OPTIONS request. In response to any preflight
	// OPTIONS request, Amazon S3 returns any requested headers that are allowed.
	AllowedHeaders []string

	// One or more headers in the response that you want customers to be able to access
	// from their applications (for example, from a JavaScript XMLHttpRequest object).
	ExposeHeaders []string

	// The time in seconds that your browser is to cache the preflight response for the
	// specified resource.
	MaxAgeSeconds int32
}

// The configuration information for the bucket.
type CreateBucketConfiguration struct {

	// Specifies the Region where the bucket will be created. If you don't specify a
	// Region, the bucket is created in the US East (N. Virginia) Region (us-east-1).
	LocationConstraint BucketLocationConstraint
}

// Describes how an uncompressed comma-separated values (CSV)-formatted input
// object is formatted.
type CSVInput struct {

	// Specifies that CSV field values may contain quoted record delimiters and such
	// records should be allowed. Default value is FALSE. Setting this value to TRUE
	// may lower performance.
	AllowQuotedRecordDelimiter bool

	// A single character used to indicate that a row should be ignored when the
	// character is present at the start of that row. You can specify any character to
	// indicate a comment line.
	Comments *string

	// A single character used to separate individual fields in a record. You can
	// specify an arbitrary delimiter.
	FieldDelimiter *string

	// Describes the first line of input. Valid values are:
	//
	// * NONE: First line is not
	// a header.
	//
	// * IGNORE: First line is a header, but you can't use the header values
	// to indicate the column in an expression. You can use column position (such as
	// _1, _2, …) to indicate the column (SELECT s._1 FROM OBJECT s).
	//
	// * Use: First
	// line is a header, and you can use the header value to identify a column in an
	// expression (SELECT "name" FROM OBJECT).
	FileHeaderInfo FileHeaderInfo

	// A single character used for escaping when the field delimiter is part of the
	// value. For example, if the value is a, b, Amazon S3 wraps this field value in
	// quotation marks, as follows: " a , b ". Type: String Default: " Ancestors: CSV
	QuoteCharacter *string

	// A single character used for escaping the quotation mark character inside an
	// already escaped value. For example, the value """ a , b """ is parsed as " a , b
	// ".
	QuoteEscapeCharacter *string

	// A single character used to separate individual records in the input. Instead of
	// the default value, you can specify an arbitrary delimiter.
	RecordDelimiter *string
}

// Describes how uncompressed comma-separated values (CSV)-formatted results are
// formatted.
type CSVOutput struct {

	// The value used to separate individual fields in a record. You can specify an
	// arbitrary delimiter.
	FieldDelimiter *string

	// A single character used for escaping when the field delimiter is part of the
	// value. For example, if the value is a, b, Amazon S3 wraps this field value in
	// quotation marks, as follows: " a , b ".
	QuoteCharacter *string

	// The single character used for escaping the quote character inside an already
	// escaped value.
	QuoteEscapeCharacter *string

	// Indicates whether to use quotation marks around output fields.
	//
	// * ALWAYS: Always
	// use quotation marks for output fields.
	//
	// * ASNEEDED: Use quotation marks for
	// output fields when needed.
	QuoteFields QuoteFields

	// A single character used to separate individual records in the output. Instead of
	// the default value, you can specify an arbitrary delimiter.
	RecordDelimiter *string
}

// The container element for specifying the default Object Lock retention settings
// for new objects placed in the specified bucket.
type DefaultRetention struct {

	// The number of days that you want to specify for the default retention period.
	Days int32

	// The default Object Lock retention mode you want to apply to new objects placed
	// in the specified bucket.
	Mode ObjectLockRetentionMode

	// The number of years that you want to specify for the default retention period.
	Years int32
}

// Container for the objects to delete.
type Delete struct {

	// The objects to delete.
	//
	// This member is required.
	Objects []ObjectIdentifier

	// Element to enable quiet mode for the request. When you add this element, you
	// must set its value to true.
	Quiet bool
}

// Information about the deleted object.
type DeletedObject struct {

	// Specifies whether the versioned object that was permanently deleted was (true)
	// or was not (false) a delete marker. In a simple DELETE, this header indicates
	// whether (true) or not (false) a delete marker was created.
	DeleteMarker bool

	// The version ID of the delete marker created as a result of the DELETE operation.
	// If you delete a specific object version, the value returned by this header is
	// the version ID of the object version deleted.
	DeleteMarkerVersionId *string

	// The name of the deleted object.
	Key *string

	// The version ID of the deleted object.
	VersionId *string
}

// Information about the delete marker.
type DeleteMarkerEntry struct {

	// Specifies whether the object is (true) or is not (false) the latest version of
	// an object.
	IsLatest bool

	// The object key.
	Key *string

	// Date and time the object was last modified.
	LastModified *time.Time

	// The account that created the delete marker.>
	Owner *Owner

	// Version ID of an object.
	VersionId *string
}

// Specifies whether Amazon S3 replicates delete markers. If you specify a Filter
// in your replication configuration, you must also include a
// DeleteMarkerReplication element. If your Filter includes a Tag element, the
// DeleteMarkerReplicationStatus must be set to Disabled, because Amazon S3 does
// not support replicating delete markers for tag-based rules. For an example
// configuration, see Basic Rule Configuration
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-config-min-rule-config).
// For more information about delete marker replication, see Basic Rule
// Configuration
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/delete-marker-replication.html).
// If you are using an earlier version of the replication configuration, Amazon S3
// handles replication of delete markers differently. For more information, see
// Backward Compatibility
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-backward-compat-considerations).
type DeleteMarkerReplication struct {

	// Indicates whether to replicate delete markers. Indicates whether to replicate
	// delete markers.
	Status DeleteMarkerReplicationStatus
}

// Specifies information about where to publish analysis or configuration results
// for an Amazon S3 bucket and S3 Replication Time Control (S3 RTC).
type Destination struct {

	// The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to store
	// the results.
	//
	// This member is required.
	Bucket *string

	// Specify this only in a cross-account scenario (where source and destination
	// bucket owners are not the same), and you want to change replica ownership to the
	// AWS account that owns the destination bucket. If this is not specified in the
	// replication configuration, the replicas are owned by same AWS account that owns
	// the source object.
	AccessControlTranslation *AccessControlTranslation

	// Destination bucket owner account ID. In a cross-account scenario, if you direct
	// Amazon S3 to change replica ownership to the AWS account that owns the
	// destination bucket by specifying the AccessControlTranslation property, this is
	// the account ID of the destination bucket owner. For more information, see
	// Replication Additional Configuration: Changing the Replica Owner
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-change-owner.html)
	// in the Amazon Simple Storage Service Developer Guide.
	Account *string

	// A container that provides information about encryption. If
	// SourceSelectionCriteria is specified, you must specify this element.
	EncryptionConfiguration *EncryptionConfiguration

	// A container specifying replication metrics-related settings enabling replication
	// metrics and events.
	Metrics *Metrics

	// A container specifying S3 Replication Time Control (S3 RTC), including whether
	// S3 RTC is enabled and the time when all objects and operations on objects must
	// be replicated. Must be specified together with a Metrics block.
	ReplicationTime *ReplicationTime

	// The storage class to use when replicating objects, such as S3 Standard or
	// reduced redundancy. By default, Amazon S3 uses the storage class of the source
	// object to create the object replica. For valid values, see the StorageClass
	// element of the PUT Bucket replication
	// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html)
	// action in the Amazon Simple Storage Service API Reference.
	StorageClass StorageClass
}

// Contains the type of server-side encryption used.
type Encryption struct {

	// The server-side encryption algorithm used when storing job results in Amazon S3
	// (for example, AES256, aws:kms).
	//
	// This member is required.
	EncryptionType ServerSideEncryption

	// If the encryption type is aws:kms, this optional value can be used to specify
	// the encryption context for the restore results.
	KMSContext *string

	// If the encryption type is aws:kms, this optional value specifies the ID of the
	// symmetric customer managed AWS KMS CMK to use for encryption of job results.
	// Amazon S3 only supports symmetric CMKs. For more information, see Using
	// Symmetric and Asymmetric Keys
	// (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html)
	// in the AWS Key Management Service Developer Guide.
	KMSKeyId *string
}

// Specifies encryption-related information for an Amazon S3 bucket that is a
// destination for replicated objects.
type EncryptionConfiguration struct {

	// Specifies the ID (Key ARN or Alias ARN) of the customer managed customer master
	// key (CMK) stored in AWS Key Management Service (KMS) for the destination bucket.
	// Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports
	// symmetric customer managed CMKs. For more information, see Using Symmetric and
	// Asymmetric Keys
	// (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html)
	// in the AWS Key Management Service Developer Guide.
	ReplicaKmsKeyID *string
}

// Container for all error elements.
type Error struct {

	// The error code is a string that uniquely identifies an error condition. It is
	// meant to be read and understood by programs that detect and handle errors by
	// type. Amazon S3 error codes
	//
	// * Code: AccessDenied
	//
	// * Description: Access
	// Denied
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: AccountProblem
	//
	// * Description: There is a problem with your AWS account
	// that prevents the operation from completing successfully. Contact AWS Support
	// for further assistance.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: AllAccessDisabled
	//
	// * Description: All access to this
	// Amazon S3 resource has been disabled. Contact AWS Support for further
	// assistance.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: AmbiguousGrantByEmailAddress
	//
	// * Description: The email address
	// you provided is associated with more than one account.
	//
	// * HTTP Status Code: 400
	// Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// AuthorizationHeaderMalformed
	//
	// * Description: The authorization header you
	// provided is invalid.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * HTTP Status Code:
	// N/A
	//
	// * Code: BadDigest
	//
	// * Description: The Content-MD5 you specified did not
	// match what we received.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: BucketAlreadyExists
	//
	// * Description: The requested bucket
	// name is not available. The bucket namespace is shared by all users of the
	// system. Please select a different name and try again.
	//
	// * HTTP Status Code: 409
	// Conflict
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: BucketAlreadyOwnedByYou
	//
	// *
	// Description: The bucket you tried to create already exists, and you own it.
	// Amazon S3 returns this error in all AWS Regions except in the North Virginia
	// Region. For legacy compatibility, if you re-create an existing bucket that you
	// already own in the North Virginia Region, Amazon S3 returns 200 OK and resets
	// the bucket access control lists (ACLs).
	//
	// * Code: 409 Conflict (in all Regions
	// except the North Virginia Region)
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// BucketNotEmpty
	//
	// * Description: The bucket you tried to delete is not empty.
	//
	// *
	// HTTP Status Code: 409 Conflict
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// CredentialsNotSupported
	//
	// * Description: This request does not support
	// credentials.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: CrossLocationLoggingProhibited
	//
	// * Description: Cross-location
	// logging not allowed. Buckets in one geographic location cannot log information
	// to a bucket in another location.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP
	// Fault Code Prefix: Client
	//
	// * Code: EntityTooSmall
	//
	// * Description: Your proposed
	// upload is smaller than the minimum allowed object size.
	//
	// * HTTP Status Code: 400
	// Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: EntityTooLarge
	//
	// *
	// Description: Your proposed upload exceeds the maximum allowed object size.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// ExpiredToken
	//
	// * Description: The provided token has expired.
	//
	// * HTTP Status
	// Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// IllegalVersioningConfigurationException
	//
	// * Description: Indicates that the
	// versioning configuration specified in the request is invalid.
	//
	// * HTTP Status
	// Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// IncompleteBody
	//
	// * Description: You did not provide the number of bytes specified
	// by the Content-Length HTTP header
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP
	// Fault Code Prefix: Client
	//
	// * Code: IncorrectNumberOfFilesInPostRequest
	//
	// *
	// Description: POST requires exactly one file upload per request.
	//
	// * HTTP Status
	// Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InlineDataTooLarge
	//
	// * Description: Inline data exceeds the maximum allowed
	// size.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: InternalError
	//
	// * Description: We encountered an internal error. Please try
	// again.
	//
	// * HTTP Status Code: 500 Internal Server Error
	//
	// * SOAP Fault Code Prefix:
	// Server
	//
	// * Code: InvalidAccessKeyId
	//
	// * Description: The AWS access key ID you
	// provided does not exist in our records.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: InvalidAddressingHeader
	//
	// * Description:
	// You must specify the Anonymous role.
	//
	// * HTTP Status Code: N/A
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: InvalidArgument
	//
	// * Description: Invalid Argument
	//
	// * HTTP
	// Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidBucketName
	//
	// * Description: The specified bucket is not valid.
	//
	// * HTTP
	// Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidBucketState
	//
	// * Description: The request is not valid with the current
	// state of the bucket.
	//
	// * HTTP Status Code: 409 Conflict
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: InvalidDigest
	//
	// * Description: The Content-MD5 you
	// specified is not valid.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: InvalidEncryptionAlgorithmError
	//
	// * Description: The
	// encryption request you specified is not valid. The valid value is AES256.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidLocationConstraint
	//
	// * Description: The specified location constraint is
	// not valid. For more information about Regions, see How to Select a Region for
	// Your Buckets
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro).
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidObjectState
	//
	// * Description: The operation is not valid for the current
	// state of the object.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: InvalidPart
	//
	// * Description: One or more of the specified
	// parts could not be found. The part might not have been uploaded, or the
	// specified entity tag might not have matched the part's entity tag.
	//
	// * HTTP
	// Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidPartOrder
	//
	// * Description: The list of parts was not in ascending order.
	// Parts list must be specified in order by part number.
	//
	// * HTTP Status Code: 400
	// Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: InvalidPayer
	//
	// *
	// Description: All access to this object has been disabled. Please contact AWS
	// Support for further assistance.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault
	// Code Prefix: Client
	//
	// * Code: InvalidPolicyDocument
	//
	// * Description: The content
	// of the form does not meet the conditions specified in the policy document.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidRange
	//
	// * Description: The requested range cannot be satisfied.
	//
	// * HTTP
	// Status Code: 416 Requested Range Not Satisfiable
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: InvalidRequest
	//
	// * Description: Please use AWS4-HMAC-SHA256.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code: InvalidRequest
	//
	// *
	// Description: SOAP requests must be made over an HTTPS connection.
	//
	// * HTTP Status
	// Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidRequest
	//
	// * Description: Amazon S3 Transfer Acceleration is not supported
	// for buckets with non-DNS compliant names.
	//
	// * HTTP Status Code: 400 Bad
	// Request
	//
	// * Code: N/A
	//
	// * Code: InvalidRequest
	//
	// * Description: Amazon S3 Transfer
	// Acceleration is not supported for buckets with periods (.) in their names.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code: InvalidRequest
	//
	// *
	// Description: Amazon S3 Transfer Accelerate endpoint only supports virtual style
	// requests.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code:
	// InvalidRequest
	//
	// * Description: Amazon S3 Transfer Accelerate is not configured
	// on this bucket.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code:
	// InvalidRequest
	//
	// * Description: Amazon S3 Transfer Accelerate is disabled on this
	// bucket.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code:
	// InvalidRequest
	//
	// * Description: Amazon S3 Transfer Acceleration is not supported
	// on this bucket. Contact AWS Support for more information.
	//
	// * HTTP Status Code:
	// 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code: InvalidRequest
	//
	// * Description: Amazon S3
	// Transfer Acceleration cannot be enabled on this bucket. Contact AWS Support for
	// more information.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * Code: N/A
	//
	// * Code:
	// InvalidSecurity
	//
	// * Description: The provided security credentials are not
	// valid.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: InvalidSOAPRequest
	//
	// * Description: The SOAP request body is invalid.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// InvalidStorageClass
	//
	// * Description: The storage class you specified is not
	// valid.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: InvalidTargetBucketForLogging
	//
	// * Description: The target bucket for
	// logging does not exist, is not owned by you, or does not have the appropriate
	// grants for the log-delivery group.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP
	// Fault Code Prefix: Client
	//
	// * Code: InvalidToken
	//
	// * Description: The provided
	// token is malformed or otherwise invalid.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: InvalidURI
	//
	// * Description: Couldn't
	// parse the specified URI.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: KeyTooLongError
	//
	// * Description: Your key is too long.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// MalformedACLError
	//
	// * Description: The XML you provided was not well-formed or
	// did not validate against our published schema.
	//
	// * HTTP Status Code: 400 Bad
	// Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: MalformedPOSTRequest
	//
	// *
	// Description: The body of your POST request is not well-formed
	// multipart/form-data.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: MalformedXML
	//
	// * Description: This happens when the user
	// sends malformed XML (XML that doesn't conform to the published XSD) for the
	// configuration. The error message is, "The XML you provided was not well-formed
	// or did not validate against our published schema."
	//
	// * HTTP Status Code: 400 Bad
	// Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: MaxMessageLengthExceeded
	//
	// *
	// Description: Your request was too big.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: MaxPostPreDataLengthExceededError
	//
	// *
	// Description: Your POST request fields preceding the upload file were too
	// large.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: MetadataTooLarge
	//
	// * Description: Your metadata headers exceed the maximum
	// allowed metadata size.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: MethodNotAllowed
	//
	// * Description: The specified method is
	// not allowed against this resource.
	//
	// * HTTP Status Code: 405 Method Not
	// Allowed
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: MissingAttachment
	//
	// *
	// Description: A SOAP attachment was expected, but none were found.
	//
	// * HTTP Status
	// Code: N/A
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: MissingContentLength
	//
	// *
	// Description: You must provide the Content-Length HTTP header.
	//
	// * HTTP Status
	// Code: 411 Length Required
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// MissingRequestBodyError
	//
	// * Description: This happens when the user sends an
	// empty XML document as a request. The error message is, "Request body is
	// empty."
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: MissingSecurityElement
	//
	// * Description: The SOAP 1.1 request is
	// missing a security element.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault
	// Code Prefix: Client
	//
	// * Code: MissingSecurityHeader
	//
	// * Description: Your request
	// is missing a required header.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault
	// Code Prefix: Client
	//
	// * Code: NoLoggingStatusForKey
	//
	// * Description: There is no
	// such thing as a logging status subresource for a key.
	//
	// * HTTP Status Code: 400
	// Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NoSuchBucket
	//
	// *
	// Description: The specified bucket does not exist.
	//
	// * HTTP Status Code: 404 Not
	// Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NoSuchBucketPolicy
	//
	// *
	// Description: The specified bucket does not have a bucket policy.
	//
	// * HTTP Status
	// Code: 404 Not Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NoSuchKey
	//
	// *
	// Description: The specified key does not exist.
	//
	// * HTTP Status Code: 404 Not
	// Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NoSuchLifecycleConfiguration
	//
	// *
	// Description: The lifecycle configuration does not exist.
	//
	// * HTTP Status Code:
	// 404 Not Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NoSuchUpload
	//
	// *
	// Description: The specified multipart upload does not exist. The upload ID might
	// be invalid, or the multipart upload might have been aborted or completed.
	//
	// *
	// HTTP Status Code: 404 Not Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// NoSuchVersion
	//
	// * Description: Indicates that the version ID specified in the
	// request does not match an existing version.
	//
	// * HTTP Status Code: 404 Not
	// Found
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: NotImplemented
	//
	// * Description:
	// A header you provided implies functionality that is not implemented.
	//
	// * HTTP
	// Status Code: 501 Not Implemented
	//
	// * SOAP Fault Code Prefix: Server
	//
	// * Code:
	// NotSignedUp
	//
	// * Description: Your account is not signed up for the Amazon S3
	// service. You must sign up before you can use Amazon S3. You can sign up at the
	// following URL: https://aws.amazon.com/s3
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: OperationAborted
	//
	// * Description: A
	// conflicting conditional operation is currently in progress against this
	// resource. Try again.
	//
	// * HTTP Status Code: 409 Conflict
	//
	// * SOAP Fault Code
	// Prefix: Client
	//
	// * Code: PermanentRedirect
	//
	// * Description: The bucket you are
	// attempting to access must be addressed using the specified endpoint. Send all
	// future requests to this endpoint.
	//
	// * HTTP Status Code: 301 Moved Permanently
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: PreconditionFailed
	//
	// * Description: At
	// least one of the preconditions you specified did not hold.
	//
	// * HTTP Status Code:
	// 412 Precondition Failed
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: Redirect
	//
	// *
	// Description: Temporary redirect.
	//
	// * HTTP Status Code: 307 Moved Temporarily
	//
	// *
	// SOAP Fault Code Prefix: Client
	//
	// * Code: RestoreAlreadyInProgress
	//
	// * Description:
	// Object restore is already in progress.
	//
	// * HTTP Status Code: 409 Conflict
	//
	// * SOAP
	// Fault Code Prefix: Client
	//
	// * Code: RequestIsNotMultiPartContent
	//
	// * Description:
	// Bucket POST must be of the enclosure-type multipart/form-data.
	//
	// * HTTP Status
	// Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// RequestTimeout
	//
	// * Description: Your socket connection to the server was not read
	// from or written to within the timeout period.
	//
	// * HTTP Status Code: 400 Bad
	// Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: RequestTimeTooSkewed
	//
	// *
	// Description: The difference between the request time and the server's time is
	// too large.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: RequestTorrentOfBucketError
	//
	// * Description: Requesting the
	// torrent file of a bucket is not permitted.
	//
	// * HTTP Status Code: 400 Bad
	// Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code: SignatureDoesNotMatch
	//
	// *
	// Description: The request signature we calculated does not match the signature
	// you provided. Check your AWS secret access key and signing method. For more
	// information, see REST Authentication
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html) and
	// SOAP Authentication
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/SOAPAuthentication.html) for
	// details.
	//
	// * HTTP Status Code: 403 Forbidden
	//
	// * SOAP Fault Code Prefix: Client
	//
	// *
	// Code: ServiceUnavailable
	//
	// * Description: Reduce your request rate.
	//
	// * HTTP
	// Status Code: 503 Service Unavailable
	//
	// * SOAP Fault Code Prefix: Server
	//
	// * Code:
	// SlowDown
	//
	// * Description: Reduce your request rate.
	//
	// * HTTP Status Code: 503 Slow
	// Down
	//
	// * SOAP Fault Code Prefix: Server
	//
	// * Code: TemporaryRedirect
	//
	// *
	// Description: You are being redirected to the bucket while DNS updates.
	//
	// * HTTP
	// Status Code: 307 Moved Temporarily
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// TokenRefreshRequired
	//
	// * Description: The provided token must be refreshed.
	//
	// *
	// HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// TooManyBuckets
	//
	// * Description: You have attempted to create more buckets than
	// allowed.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: UnexpectedContent
	//
	// * Description: This request does not support
	// content.
	//
	// * HTTP Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix:
	// Client
	//
	// * Code: UnresolvableGrantByEmailAddress
	//
	// * Description: The email
	// address you provided does not match any account on record.
	//
	// * HTTP Status Code:
	// 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	//
	// * Code:
	// UserKeyMustBeSpecified
	//
	// * Description: The bucket POST must contain the
	// specified field name. If it is specified, check the order of the fields.
	//
	// * HTTP
	// Status Code: 400 Bad Request
	//
	// * SOAP Fault Code Prefix: Client
	Code *string

	// The error key.
	Key *string

	// The error message contains a generic description of the error condition in
	// English. It is intended for a human audience. Simple programs display the
	// message directly to the end user if they encounter an error condition they don't
	// know how or don't care to handle. Sophisticated programs with more exhaustive
	// error handling and proper internationalization are more likely to ignore the
	// error message.
	Message *string

	// The version ID of the error.
	VersionId *string
}

// The error information.
type ErrorDocument struct {

	// The object key name to use when a 4XX class error occurs.
	//
	// This member is required.
	Key *string
}

// Optional configuration to replicate existing source bucket objects. For more
// information, see Replicating Existing Objects
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-what-is-isnot-replicated.html#existing-object-replication)
// in the Amazon S3 Developer Guide.
type ExistingObjectReplication struct {

	//
	//
	// This member is required.
	Status ExistingObjectReplicationStatus
}

// Specifies the Amazon S3 object key name to filter on and whether to filter on
// the suffix or prefix of the key name.
type FilterRule struct {

	// The object key name prefix or suffix identifying one or more objects to which
	// the filtering rule applies. The maximum length is 1,024 characters. Overlapping
	// prefixes and suffixes are not supported. For more information, see Configuring
	// Event Notifications
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	Name FilterRuleName

	// The value that the filter searches for in object key names.
	Value *string
}

// Container for S3 Glacier job parameters.
type GlacierJobParameters struct {

	// Retrieval tier at which the restore will be processed.
	//
	// This member is required.
	Tier Tier
}

// Container for grant information.
type Grant struct {

	// The person being granted permissions.
	Grantee *Grantee

	// Specifies the permission given to the grantee.
	Permission Permission
}

// Container for the person being granted permissions.
type Grantee struct {

	// Type of grantee
	//
	// This member is required.
	Type Type

	// Screen name of the grantee.
	DisplayName *string

	// Email address of the grantee. Using email addresses to specify a grantee is only
	// supported in the following AWS Regions:
	//
	// * US East (N. Virginia)
	//
	// * US West (N.
	// California)
	//
	// * US West (Oregon)
	//
	// * Asia Pacific (Singapore)
	//
	// * Asia Pacific
	// (Sydney)
	//
	// * Asia Pacific (Tokyo)
	//
	// * Europe (Ireland)
	//
	// * South America (São
	// Paulo)
	//
	// For a list of all the Amazon S3 supported Regions and endpoints, see
	// Regions and Endpoints
	// (https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in the AWS
	// General Reference.
	EmailAddress *string

	// The canonical user ID of the grantee.
	ID *string

	// URI of the grantee group.
	URI *string
}

// Container for the Suffix element.
type IndexDocument struct {

	// A suffix that is appended to a request that is for a directory on the website
	// endpoint (for example,if the suffix is index.html and you make a request to
	// samplebucket/images/ the data that is returned will be for the object with the
	// key name images/index.html) The suffix must not be empty and must not include a
	// slash character.
	//
	// This member is required.
	Suffix *string
}

// Container element that identifies who initiated the multipart upload.
type Initiator struct {

	// Name of the Principal.
	DisplayName *string

	// If the principal is an AWS account, it provides the Canonical User ID. If the
	// principal is an IAM User, it provides a user ARN value.
	ID *string
}

// Describes the serialization format of the object.
type InputSerialization struct {

	// Describes the serialization of a CSV-encoded object.
	CSV *CSVInput

	// Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default
	// Value: NONE.
	CompressionType CompressionType

	// Specifies JSON as object's input serialization format.
	JSON *JSONInput

	// Specifies Parquet as object's input serialization format.
	Parquet *ParquetInput
}

// A container for specifying S3 Intelligent-Tiering filters. The filters determine
// the subset of objects to which the rule applies.
type IntelligentTieringAndOperator struct {

	// An object key name prefix that identifies the subset of objects to which the
	// configuration applies.
	Prefix *string

	// All of these tags must exist in the object's tag set in order for the
	// configuration to apply.
	Tags []Tag
}

// Specifies the S3 Intelligent-Tiering configuration for an Amazon S3 bucket. For
// information about the S3 Intelligent-Tiering storage class, see Storage class
// for automatically optimizing frequently and infrequently accessed objects
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html#sc-dynamic-data-access).
type IntelligentTieringConfiguration struct {

	// The ID used to identify the S3 Intelligent-Tiering configuration.
	//
	// This member is required.
	Id *string

	// Specifies the status of the configuration.
	//
	// This member is required.
	Status IntelligentTieringStatus

	// Specifies the S3 Intelligent-Tiering storage class tier of the configuration.
	//
	// This member is required.
	Tierings []Tiering

	// Specifies a bucket filter. The configuration only includes objects that meet the
	// filter's criteria.
	Filter *IntelligentTieringFilter
}

// The Filter is used to identify objects that the S3 Intelligent-Tiering
// configuration applies to.
type IntelligentTieringFilter struct {

	// A conjunction (logical AND) of predicates, which is used in evaluating a metrics
	// filter. The operator must have at least two predicates, and an object must match
	// all of the predicates in order for the filter to apply.
	And *IntelligentTieringAndOperator

	// An object key name prefix that identifies the subset of objects to which the
	// rule applies.
	Prefix *string

	// A container of a key value name pair.
	Tag *Tag
}

// Specifies the inventory configuration for an Amazon S3 bucket. For more
// information, see GET Bucket inventory
// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETInventoryConfig.html)
// in the Amazon Simple Storage Service API Reference.
type InventoryConfiguration struct {

	// Contains information about where to publish the inventory results.
	//
	// This member is required.
	Destination *InventoryDestination

	// The ID used to identify the inventory configuration.
	//
	// This member is required.
	Id *string

	// Object versions to include in the inventory list. If set to All, the list
	// includes all the object versions, which adds the version-related fields
	// VersionId, IsLatest, and DeleteMarker to the list. If set to Current, the list
	// does not contain these version-related fields.
	//
	// This member is required.
	IncludedObjectVersions InventoryIncludedObjectVersions

	// Specifies whether the inventory is enabled or disabled. If set to True, an
	// inventory list is generated. If set to False, no inventory list is generated.
	//
	// This member is required.
	IsEnabled bool

	// Specifies the schedule for generating inventory results.
	//
	// This member is required.
	Schedule *InventorySchedule

	// Specifies an inventory filter. The inventory only includes objects that meet the
	// filter's criteria.
	Filter *InventoryFilter

	// Contains the optional fields that are included in the inventory results.
	OptionalFields []InventoryOptionalField
}

// Specifies the inventory configuration for an Amazon S3 bucket.
type InventoryDestination struct {

	// Contains the bucket name, file format, bucket owner (optional), and prefix
	// (optional) where inventory results are published.
	//
	// This member is required.
	S3BucketDestination *InventoryS3BucketDestination
}

// Contains the type of server-side encryption used to encrypt the inventory
// results.
type InventoryEncryption struct {

	// Specifies the use of SSE-KMS to encrypt delivered inventory reports.
	SSEKMS *SSEKMS

	// Specifies the use of SSE-S3 to encrypt delivered inventory reports.
	SSES3 *SSES3
}

// Specifies an inventory filter. The inventory only includes objects that meet the
// filter's criteria.
type InventoryFilter struct {

	// The prefix that an object must have to be included in the inventory results.
	//
	// This member is required.
	Prefix *string
}

// Contains the bucket name, file format, bucket owner (optional), and prefix
// (optional) where inventory results are published.
type InventoryS3BucketDestination struct {

	// The Amazon Resource Name (ARN) of the bucket where inventory results will be
	// published.
	//
	// This member is required.
	Bucket *string

	// Specifies the output format of the inventory results.
	//
	// This member is required.
	Format InventoryFormat

	// The account ID that owns the destination S3 bucket. If no account ID is
	// provided, the owner is not validated before exporting data. Although this value
	// is optional, we strongly recommend that you set it to help prevent problems if
	// the destination bucket ownership changes.
	AccountId *string

	// Contains the type of server-side encryption used to encrypt the inventory
	// results.
	Encryption *InventoryEncryption

	// The prefix that is prepended to all inventory results.
	Prefix *string
}

// Specifies the schedule for generating inventory results.
type InventorySchedule struct {

	// Specifies how frequently inventory results are produced.
	//
	// This member is required.
	Frequency InventoryFrequency
}

// Specifies JSON as object's input serialization format.
type JSONInput struct {

	// The type of JSON. Valid values: Document, Lines.
	Type JSONType
}

// Specifies JSON as request's output serialization format.
type JSONOutput struct {

	// The value used to separate individual records in the output. If no value is
	// specified, Amazon S3 uses a newline character ('\n').
	RecordDelimiter *string
}

// A container for specifying the configuration for AWS Lambda notifications.
type LambdaFunctionConfiguration struct {

	// The Amazon S3 bucket event for which to invoke the AWS Lambda function. For more
	// information, see Supported Event Types
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	//
	// This member is required.
	Events []Event

	// The Amazon Resource Name (ARN) of the AWS Lambda function that Amazon S3 invokes
	// when the specified event type occurs.
	//
	// This member is required.
	LambdaFunctionArn *string

	// Specifies object key name filtering rules. For information about key name
	// filtering, see Configuring Event Notifications
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	Filter *NotificationConfigurationFilter

	// An optional unique identifier for configurations in a notification
	// configuration. If you don't provide one, Amazon S3 will assign an ID.
	Id *string
}

// Container for the expiration for the lifecycle of the object.
type LifecycleExpiration struct {

	// Indicates at what date the object is to be moved or deleted. Should be in GMT
	// ISO 8601 Format.
	Date *time.Time

	// Indicates the lifetime, in days, of the objects that are subject to the rule.
	// The value must be a non-zero positive integer.
	Days int32

	// Indicates whether Amazon S3 will remove a delete marker with no noncurrent
	// versions. If set to true, the delete marker will be expired; if set to false the
	// policy takes no action. This cannot be specified with Days or Date in a
	// Lifecycle Expiration Policy.
	ExpiredObjectDeleteMarker bool
}

// A lifecycle rule for individual objects in an Amazon S3 bucket.
type LifecycleRule struct {

	// If 'Enabled', the rule is currently being applied. If 'Disabled', the rule is
	// not currently being applied.
	//
	// This member is required.
	Status ExpirationStatus

	// Specifies the days since the initiation of an incomplete multipart upload that
	// Amazon S3 will wait before permanently removing all parts of the upload. For
	// more information, see  Aborting Incomplete Multipart Uploads Using a Bucket
	// Lifecycle Policy
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config)
	// in the Amazon Simple Storage Service Developer Guide.
	AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload

	// Specifies the expiration for the lifecycle of the object in the form of date,
	// days and, whether the object has a delete marker.
	Expiration *LifecycleExpiration

	// The Filter is used to identify objects that a Lifecycle Rule applies to. A
	// Filter must have exactly one of Prefix, Tag, or And specified.
	Filter LifecycleRuleFilter

	// Unique identifier for the rule. The value cannot be longer than 255 characters.
	ID *string

	// Specifies when noncurrent object versions expire. Upon expiration, Amazon S3
	// permanently deletes the noncurrent object versions. You set this lifecycle
	// configuration action on a bucket that has versioning enabled (or suspended) to
	// request that Amazon S3 delete noncurrent object versions at a specific period in
	// the object's lifetime.
	NoncurrentVersionExpiration *NoncurrentVersionExpiration

	// Specifies the transition rule for the lifecycle rule that describes when
	// noncurrent objects transition to a specific storage class. If your bucket is
	// versioning-enabled (or versioning is suspended), you can set this action to
	// request that Amazon S3 transition noncurrent object versions to a specific
	// storage class at a set period in the object's lifetime.
	NoncurrentVersionTransitions []NoncurrentVersionTransition

	// Prefix identifying one or more objects to which the rule applies. This is No
	// longer used; use Filter instead.
	//
	// Deprecated: This member has been deprecated.
	Prefix *string

	// Specifies when an Amazon S3 object transitions to a specified storage class.
	Transitions []Transition
}

// This is used in a Lifecycle Rule Filter to apply a logical AND to two or more
// predicates. The Lifecycle Rule will apply to any object matching all of the
// predicates configured inside the And operator.
type LifecycleRuleAndOperator struct {

	// Prefix identifying one or more objects to which the rule applies.
	Prefix *string

	// All of these tags must exist in the object's tag set in order for the rule to
	// apply.
	Tags []Tag
}

// The Filter is used to identify objects that a Lifecycle Rule applies to. A
// Filter must have exactly one of Prefix, Tag, or And specified.
//
// The following types satisfy this interface:
//  LifecycleRuleFilterMemberPrefix
//  LifecycleRuleFilterMemberTag
//  LifecycleRuleFilterMemberAnd
type LifecycleRuleFilter interface {
	isLifecycleRuleFilter()
}

// Prefix identifying one or more objects to which the rule applies.
type LifecycleRuleFilterMemberPrefix struct {
	Value string
}

func (*LifecycleRuleFilterMemberPrefix) isLifecycleRuleFilter() {}

// This tag must exist in the object's tag set in order for the rule to apply.
type LifecycleRuleFilterMemberTag struct {
	Value Tag
}

func (*LifecycleRuleFilterMemberTag) isLifecycleRuleFilter() {}

// This is used in a Lifecycle Rule Filter to apply a logical AND to two or more
// predicates. The Lifecycle Rule will apply to any object matching all of the
// predicates configured inside the And operator.
type LifecycleRuleFilterMemberAnd struct {
	Value LifecycleRuleAndOperator
}

func (*LifecycleRuleFilterMemberAnd) isLifecycleRuleFilter() {}

// Describes where logs are stored and the prefix that Amazon S3 assigns to all log
// object keys for a bucket. For more information, see PUT Bucket logging
// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html) in
// the Amazon Simple Storage Service API Reference.
type LoggingEnabled struct {

	// Specifies the bucket where you want Amazon S3 to store server access logs. You
	// can have your logs delivered to any bucket that you own, including the same
	// bucket that is being logged. You can also configure multiple buckets to deliver
	// their logs to the same target bucket. In this case, you should choose a
	// different TargetPrefix for each source bucket so that the delivered log files
	// can be distinguished by key.
	//
	// This member is required.
	TargetBucket *string

	// A prefix for all log object keys. If you store log files from multiple Amazon S3
	// buckets in a single bucket, you can use a prefix to distinguish which log files
	// came from which bucket.
	//
	// This member is required.
	TargetPrefix *string

	// Container for granting information.
	TargetGrants []TargetGrant
}

// A metadata key-value pair to store with an object.
type MetadataEntry struct {

	// Name of the Object.
	Name *string

	// Value of the Object.
	Value *string
}

// A container specifying replication metrics-related settings enabling replication
// metrics and events.
type Metrics struct {

	// Specifies whether the replication metrics are enabled.
	//
	// This member is required.
	Status MetricsStatus

	// A container specifying the time threshold for emitting the
	// s3:Replication:OperationMissedThreshold event.
	EventThreshold *ReplicationTimeValue
}

// A conjunction (logical AND) of predicates, which is used in evaluating a metrics
// filter. The operator must have at least two predicates, and an object must match
// all of the predicates in order for the filter to apply.
type MetricsAndOperator struct {

	// The prefix used when evaluating an AND predicate.
	Prefix *string

	// The list of tags used when evaluating an AND predicate.
	Tags []Tag
}

// Specifies a metrics configuration for the CloudWatch request metrics (specified
// by the metrics configuration ID) from an Amazon S3 bucket. If you're updating an
// existing metrics configuration, note that this is a full replacement of the
// existing metrics configuration. If you don't include the elements you want to
// keep, they are erased. For more information, see  PUT Bucket metrics
// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTMetricConfiguration.html)
// in the Amazon Simple Storage Service API Reference.
type MetricsConfiguration struct {

	// The ID used to identify the metrics configuration.
	//
	// This member is required.
	Id *string

	// Specifies a metrics configuration filter. The metrics configuration will only
	// include objects that meet the filter's criteria. A filter must be a prefix, a
	// tag, or a conjunction (MetricsAndOperator).
	Filter MetricsFilter
}

// Specifies a metrics configuration filter. The metrics configuration only
// includes objects that meet the filter's criteria. A filter must be a prefix, a
// tag, or a conjunction (MetricsAndOperator).
//
// The following types satisfy this interface:
//  MetricsFilterMemberPrefix
//  MetricsFilterMemberTag
//  MetricsFilterMemberAnd
type MetricsFilter interface {
	isMetricsFilter()
}

// The prefix used when evaluating a metrics filter.
type MetricsFilterMemberPrefix struct {
	Value string
}

func (*MetricsFilterMemberPrefix) isMetricsFilter() {}

// The tag used when evaluating a metrics filter.
type MetricsFilterMemberTag struct {
	Value Tag
}

func (*MetricsFilterMemberTag) isMetricsFilter() {}

// A conjunction (logical AND) of predicates, which is used in evaluating a metrics
// filter. The operator must have at least two predicates, and an object must match
// all of the predicates in order for the filter to apply.
type MetricsFilterMemberAnd struct {
	Value MetricsAndOperator
}

func (*MetricsFilterMemberAnd) isMetricsFilter() {}

// Container for the MultipartUpload for the Amazon S3 object.
type MultipartUpload struct {

	// Date and time at which the multipart upload was initiated.
	Initiated *time.Time

	// Identifies who initiated the multipart upload.
	Initiator *Initiator

	// Key of the object for which the multipart upload was initiated.
	Key *string

	// Specifies the owner of the object that is part of the multipart upload.
	Owner *Owner

	// The class of storage used to store the object.
	StorageClass StorageClass

	// Upload ID that identifies the multipart upload.
	UploadId *string
}

// Specifies when noncurrent object versions expire. Upon expiration, Amazon S3
// permanently deletes the noncurrent object versions. You set this lifecycle
// configuration action on a bucket that has versioning enabled (or suspended) to
// request that Amazon S3 delete noncurrent object versions at a specific period in
// the object's lifetime.
type NoncurrentVersionExpiration struct {

	// Specifies the number of days an object is noncurrent before Amazon S3 can
	// perform the associated action. For information about the noncurrent days
	// calculations, see How Amazon S3 Calculates When an Object Became Noncurrent
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/intro-lifecycle-rules.html#non-current-days-calculations)
	// in the Amazon Simple Storage Service Developer Guide.
	NoncurrentDays int32
}

// Container for the transition rule that describes when noncurrent objects
// transition to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, GLACIER, or
// DEEP_ARCHIVE storage class. If your bucket is versioning-enabled (or versioning
// is suspended), you can set this action to request that Amazon S3 transition
// noncurrent object versions to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING,
// GLACIER, or DEEP_ARCHIVE storage class at a specific period in the object's
// lifetime.
type NoncurrentVersionTransition struct {

	// Specifies the number of days an object is noncurrent before Amazon S3 can
	// perform the associated action. For information about the noncurrent days
	// calculations, see How Amazon S3 Calculates How Long an Object Has Been
	// Noncurrent
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/intro-lifecycle-rules.html#non-current-days-calculations)
	// in the Amazon Simple Storage Service Developer Guide.
	NoncurrentDays int32

	// The class of storage used to store the object.
	StorageClass TransitionStorageClass
}

// A container for specifying the notification configuration of the bucket. If this
// element is empty, notifications are turned off for the bucket.
type NotificationConfiguration struct {

	// Describes the AWS Lambda functions to invoke and the events for which to invoke
	// them.
	LambdaFunctionConfigurations []LambdaFunctionConfiguration

	// The Amazon Simple Queue Service queues to publish messages to and the events for
	// which to publish messages.
	QueueConfigurations []QueueConfiguration

	// The topic to which notifications are sent and the events for which notifications
	// are generated.
	TopicConfigurations []TopicConfiguration
}

// Specifies object key name filtering rules. For information about key name
// filtering, see Configuring Event Notifications
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
// Amazon Simple Storage Service Developer Guide.
type NotificationConfigurationFilter struct {

	// A container for object key name prefix and suffix filtering rules.
	Key *S3KeyFilter
}

// An object consists of data and its descriptive metadata.
type Object struct {

	// The entity tag is a hash of the object. The ETag reflects changes only to the
	// contents of an object, not its metadata. The ETag may or may not be an MD5
	// digest of the object data. Whether or not it is depends on how the object was
	// created and how it is encrypted as described below:
	//
	// * Objects created by the
	// PUT Object, POST Object, or Copy operation, or through the AWS Management
	// Console, and are encrypted by SSE-S3 or plaintext, have ETags that are an MD5
	// digest of their object data.
	//
	// * Objects created by the PUT Object, POST Object,
	// or Copy operation, or through the AWS Management Console, and are encrypted by
	// SSE-C or SSE-KMS, have ETags that are not an MD5 digest of their object data.
	//
	// *
	// If an object is created by either the Multipart Upload or Part Copy operation,
	// the ETag is not an MD5 digest, regardless of the method of encryption.
	ETag *string

	// The name that you assign to an object. You use the object key to retrieve the
	// object.
	Key *string

	// The date the Object was Last Modified
	LastModified *time.Time

	// The owner of the object
	Owner *Owner

	// Size in bytes of the object
	Size int64

	// The class of storage used to store the object.
	StorageClass ObjectStorageClass
}

// Object Identifier is unique value to identify objects.
type ObjectIdentifier struct {

	// Key name of the object to delete.
	//
	// This member is required.
	Key *string

	// VersionId for the specific version of the object to delete.
	VersionId *string
}

// The container element for Object Lock configuration parameters.
type ObjectLockConfiguration struct {

	// Indicates whether this bucket has an Object Lock configuration enabled.
	ObjectLockEnabled ObjectLockEnabled

	// The Object Lock rule in place for the specified object.
	Rule *ObjectLockRule
}

// A Legal Hold configuration for an object.
type ObjectLockLegalHold struct {

	// Indicates whether the specified object has a Legal Hold in place.
	Status ObjectLockLegalHoldStatus
}

// A Retention configuration for an object.
type ObjectLockRetention struct {

	// Indicates the Retention mode for the specified object.
	Mode ObjectLockRetentionMode

	// The date on which this Object Lock Retention will expire.
	RetainUntilDate *time.Time
}

// The container element for an Object Lock rule.
type ObjectLockRule struct {

	// The default retention period that you want to apply to new objects placed in the
	// specified bucket.
	DefaultRetention *DefaultRetention
}

// The version of an object.
type ObjectVersion struct {

	// The entity tag is an MD5 hash of that version of the object.
	ETag *string

	// Specifies whether the object is (true) or is not (false) the latest version of
	// an object.
	IsLatest bool

	// The object key.
	Key *string

	// Date and time the object was last modified.
	LastModified *time.Time

	// Specifies the owner of the object.
	Owner *Owner

	// Size in bytes of the object.
	Size int64

	// The class of storage used to store the object.
	StorageClass ObjectVersionStorageClass

	// Version ID of an object.
	VersionId *string
}

// Describes the location where the restore job's output is stored.
type OutputLocation struct {

	// Describes an S3 location that will receive the results of the restore request.
	S3 *S3Location
}

// Describes how results of the Select job are serialized.
type OutputSerialization struct {

	// Describes the serialization of CSV-encoded Select results.
	CSV *CSVOutput

	// Specifies JSON as request's output serialization format.
	JSON *JSONOutput
}

// Container for the owner's display name and ID.
type Owner struct {

	// Container for the display name of the owner.
	DisplayName *string

	// Container for the ID of the owner.
	ID *string
}

// The container element for a bucket's ownership controls.
type OwnershipControls struct {

	// The container element for an ownership control rule.
	//
	// This member is required.
	Rules []OwnershipControlsRule
}

// The container element for an ownership control rule.
type OwnershipControlsRule struct {

	// The container element for object ownership for a bucket's ownership controls.
	// BucketOwnerPreferred - Objects uploaded to the bucket change ownership to the
	// bucket owner if the objects are uploaded with the bucket-owner-full-control
	// canned ACL. ObjectWriter - The uploading account will own the object if the
	// object is uploaded with the bucket-owner-full-control canned ACL.
	//
	// This member is required.
	ObjectOwnership ObjectOwnership
}

// Container for Parquet.
type ParquetInput struct {
}

// Container for elements related to a part.
type Part struct {

	// Entity tag returned when the part was uploaded.
	ETag *string

	// Date and time at which the part was uploaded.
	LastModified *time.Time

	// Part number identifying the part. This is a positive integer between 1 and
	// 10,000.
	PartNumber int32

	// Size in bytes of the uploaded part data.
	Size int64
}

// The container element for a bucket's policy status.
type PolicyStatus struct {

	// The policy status for this bucket. TRUE indicates that this bucket is public.
	// FALSE indicates that the bucket is not public.
	IsPublic bool
}

// The PublicAccessBlock configuration that you want to apply to this Amazon S3
// bucket. You can enable the configuration options in any combination. For more
// information about when Amazon S3 considers a bucket or object public, see The
// Meaning of "Public"
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status)
// in the Amazon Simple Storage Service Developer Guide.
type PublicAccessBlockConfiguration struct {

	// Specifies whether Amazon S3 should block public access control lists (ACLs) for
	// this bucket and objects in this bucket. Setting this element to TRUE causes the
	// following behavior:
	//
	// * PUT Bucket acl and PUT Object acl calls fail if the
	// specified ACL is public.
	//
	// * PUT Object calls fail if the request includes a
	// public ACL.
	//
	// * PUT Bucket calls fail if the request includes a public
	// ACL.
	//
	// Enabling this setting doesn't affect existing policies or ACLs.
	BlockPublicAcls bool

	// Specifies whether Amazon S3 should block public bucket policies for this bucket.
	// Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket
	// policy if the specified bucket policy allows public access. Enabling this
	// setting doesn't affect existing bucket policies.
	BlockPublicPolicy bool

	// Specifies whether Amazon S3 should ignore public ACLs for this bucket and
	// objects in this bucket. Setting this element to TRUE causes Amazon S3 to ignore
	// all public ACLs on this bucket and objects in this bucket. Enabling this setting
	// doesn't affect the persistence of any existing ACLs and doesn't prevent new
	// public ACLs from being set.
	IgnorePublicAcls bool

	// Specifies whether Amazon S3 should restrict public bucket policies for this
	// bucket. Setting this element to TRUE restricts access to this bucket to only AWS
	// service principals and authorized users within this account if the bucket has a
	// public policy. Enabling this setting doesn't affect previously stored bucket
	// policies, except that public and cross-account access within any public bucket
	// policy, including non-public delegation to specific accounts, is blocked.
	RestrictPublicBuckets bool
}

// Specifies the configuration for publishing messages to an Amazon Simple Queue
// Service (Amazon SQS) queue when Amazon S3 detects specified events.
type QueueConfiguration struct {

	// A collection of bucket events for which to send notifications
	//
	// This member is required.
	Events []Event

	// The Amazon Resource Name (ARN) of the Amazon SQS queue to which Amazon S3
	// publishes a message when it detects events of the specified type.
	//
	// This member is required.
	QueueArn *string

	// Specifies object key name filtering rules. For information about key name
	// filtering, see Configuring Event Notifications
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	Filter *NotificationConfigurationFilter

	// An optional unique identifier for configurations in a notification
	// configuration. If you don't provide one, Amazon S3 will assign an ID.
	Id *string
}

// Specifies how requests are redirected. In the event of an error, you can specify
// a different error code to return.
type Redirect struct {

	// The host name to use in the redirect request.
	HostName *string

	// The HTTP redirect code to use on the response. Not required if one of the
	// siblings is present.
	HttpRedirectCode *string

	// Protocol to use when redirecting requests. The default is the protocol that is
	// used in the original request.
	Protocol Protocol

	// The object key prefix to use in the redirect request. For example, to redirect
	// requests for all pages with prefix docs/ (objects in the docs/ folder) to
	// documents/, you can set a condition block with KeyPrefixEquals set to docs/ and
	// in the Redirect set ReplaceKeyPrefixWith to /documents. Not required if one of
	// the siblings is present. Can be present only if ReplaceKeyWith is not provided.
	ReplaceKeyPrefixWith *string

	// The specific object key to use in the redirect request. For example, redirect
	// request to error.html. Not required if one of the siblings is present. Can be
	// present only if ReplaceKeyPrefixWith is not provided.
	ReplaceKeyWith *string
}

// Specifies the redirect behavior of all requests to a website endpoint of an
// Amazon S3 bucket.
type RedirectAllRequestsTo struct {

	// Name of the host where requests are redirected.
	//
	// This member is required.
	HostName *string

	// Protocol to use when redirecting requests. The default is the protocol that is
	// used in the original request.
	Protocol Protocol
}

// A filter that you can specify for selection for modifications on replicas.
// Amazon S3 doesn't replicate replica modifications by default. In the latest
// version of replication configuration (when Filter is specified), you can specify
// this element and set the status to Enabled to replicate modifications on
// replicas. If you don't specify the Filter element, Amazon S3 assumes that the
// replication configuration is the earlier version, V1. In the earlier version,
// this element is not allowed.
type ReplicaModifications struct {

	// Specifies whether Amazon S3 replicates modifications on replicas.
	//
	// This member is required.
	Status ReplicaModificationsStatus
}

// A container for replication rules. You can add up to 1,000 rules. The maximum
// size of a replication configuration is 2 MB.
type ReplicationConfiguration struct {

	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
	// role that Amazon S3 assumes when replicating objects. For more information, see
	// How to Set Up Replication
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-how-setup.html) in
	// the Amazon Simple Storage Service Developer Guide.
	//
	// This member is required.
	Role *string

	// A container for one or more replication rules. A replication configuration must
	// have at least one rule and can contain a maximum of 1,000 rules.
	//
	// This member is required.
	Rules []ReplicationRule
}

// Specifies which Amazon S3 objects to replicate and where to store the replicas.
type ReplicationRule struct {

	// A container for information about the replication destination and its
	// configurations including enabling the S3 Replication Time Control (S3 RTC).
	//
	// This member is required.
	Destination *Destination

	// Specifies whether the rule is enabled.
	//
	// This member is required.
	Status ReplicationRuleStatus

	// Specifies whether Amazon S3 replicates delete markers. If you specify a Filter
	// in your replication configuration, you must also include a
	// DeleteMarkerReplication element. If your Filter includes a Tag element, the
	// DeleteMarkerReplicationStatus must be set to Disabled, because Amazon S3 does
	// not support replicating delete markers for tag-based rules. For an example
	// configuration, see Basic Rule Configuration
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-config-min-rule-config).
	// For more information about delete marker replication, see Basic Rule
	// Configuration
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/delete-marker-replication.html).
	// If you are using an earlier version of the replication configuration, Amazon S3
	// handles replication of delete markers differently. For more information, see
	// Backward Compatibility
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-backward-compat-considerations).
	DeleteMarkerReplication *DeleteMarkerReplication

	//
	ExistingObjectReplication *ExistingObjectReplication

	// A filter that identifies the subset of objects to which the replication rule
	// applies. A Filter must specify exactly one Prefix, Tag, or an And child element.
	Filter ReplicationRuleFilter

	// A unique identifier for the rule. The maximum value is 255 characters.
	ID *string

	// An object key name prefix that identifies the object or objects to which the
	// rule applies. The maximum prefix length is 1,024 characters. To include all
	// objects in a bucket, specify an empty string.
	//
	// Deprecated: This member has been deprecated.
	Prefix *string

	// The priority indicates which rule has precedence whenever two or more
	// replication rules conflict. Amazon S3 will attempt to replicate objects
	// according to all replication rules. However, if there are two or more rules with
	// the same destination bucket, then objects will be replicated according to the
	// rule with the highest priority. The higher the number, the higher the priority.
	// For more information, see Replication
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/replication.html) in the Amazon
	// Simple Storage Service Developer Guide.
	Priority int32

	// A container that describes additional filters for identifying the source objects
	// that you want to replicate. You can choose to enable or disable the replication
	// of these objects. Currently, Amazon S3 supports only the filter that you can
	// specify for objects created with server-side encryption using a customer master
	// key (CMK) stored in AWS Key Management Service (SSE-KMS).
	SourceSelectionCriteria *SourceSelectionCriteria
}

// A container for specifying rule filters. The filters determine the subset of
// objects to which the rule applies. This element is required only if you specify
// more than one filter. For example:
//
// * If you specify both a Prefix and a Tag
// filter, wrap these filters in an And tag.
//
// * If you specify a filter based on
// multiple tags, wrap the Tag elements in an And tag
type ReplicationRuleAndOperator struct {

	// An object key name prefix that identifies the subset of objects to which the
	// rule applies.
	Prefix *string

	// An array of tags containing key and value pairs.
	Tags []Tag
}

// A filter that identifies the subset of objects to which the replication rule
// applies. A Filter must specify exactly one Prefix, Tag, or an And child element.
//
// The following types satisfy this interface:
//  ReplicationRuleFilterMemberPrefix
//  ReplicationRuleFilterMemberTag
//  ReplicationRuleFilterMemberAnd
type ReplicationRuleFilter interface {
	isReplicationRuleFilter()
}

// An object key name prefix that identifies the subset of objects to which the
// rule applies.
type ReplicationRuleFilterMemberPrefix struct {
	Value string
}

func (*ReplicationRuleFilterMemberPrefix) isReplicationRuleFilter() {}

// A container for specifying a tag key and value. The rule applies only to objects
// that have the tag in their tag set.
type ReplicationRuleFilterMemberTag struct {
	Value Tag
}

func (*ReplicationRuleFilterMemberTag) isReplicationRuleFilter() {}

// A container for specifying rule filters. The filters determine the subset of
// objects to which the rule applies. This element is required only if you specify
// more than one filter. For example:
//
// * If you specify both a Prefix and a Tag
// filter, wrap these filters in an And tag.
//
// * If you specify a filter based on
// multiple tags, wrap the Tag elements in an And tag.
type ReplicationRuleFilterMemberAnd struct {
	Value ReplicationRuleAndOperator
}

func (*ReplicationRuleFilterMemberAnd) isReplicationRuleFilter() {}

// A container specifying S3 Replication Time Control (S3 RTC) related information,
// including whether S3 RTC is enabled and the time when all objects and operations
// on objects must be replicated. Must be specified together with a Metrics block.
type ReplicationTime struct {

	// Specifies whether the replication time is enabled.
	//
	// This member is required.
	Status ReplicationTimeStatus

	// A container specifying the time by which replication should be complete for all
	// objects and operations on objects.
	//
	// This member is required.
	Time *ReplicationTimeValue
}

// A container specifying the time value for S3 Replication Time Control (S3 RTC)
// and replication metrics EventThreshold.
type ReplicationTimeValue struct {

	// Contains an integer specifying time in minutes. Valid values: 15 minutes.
	Minutes int32
}

// Container for Payer.
type RequestPaymentConfiguration struct {

	// Specifies who pays for the download and request fees.
	//
	// This member is required.
	Payer Payer
}

// Container for restore job parameters.
type RestoreRequest struct {

	// Lifetime of the active copy in days. Do not use with restores that specify
	// OutputLocation. The Days element is required for regular restores, and must not
	// be provided for select requests.
	Days int32

	// The optional description for the job.
	Description *string

	// S3 Glacier related parameters pertaining to this job. Do not use with restores
	// that specify OutputLocation.
	GlacierJobParameters *GlacierJobParameters

	// Describes the location where the restore job's output is stored.
	OutputLocation *OutputLocation

	// Describes the parameters for Select job types.
	SelectParameters *SelectParameters

	// Retrieval tier at which the restore will be processed.
	Tier Tier

	// Type of restore request.
	Type RestoreRequestType
}

// Specifies the redirect behavior and when a redirect is applied. For more
// information about routing rules, see Configuring advanced conditional redirects
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/how-to-page-redirect.html#advanced-conditional-redirects)
// in the Amazon Simple Storage Service Developer Guide.
type RoutingRule struct {

	// Container for redirect information. You can redirect requests to another host,
	// to another page, or with another protocol. In the event of an error, you can
	// specify a different error code to return.
	//
	// This member is required.
	Redirect *Redirect

	// A container for describing a condition that must be met for the specified
	// redirect to apply. For example, 1. If request is for pages in the /docs folder,
	// redirect to the /documents folder. 2. If request results in HTTP error 4xx,
	// redirect request to another host where you might process the error.
	Condition *Condition
}

// A container for object key name prefix and suffix filtering rules.
type S3KeyFilter struct {

	// A list of containers for the key-value pair that defines the criteria for the
	// filter rule.
	FilterRules []FilterRule
}

// Describes an Amazon S3 location that will receive the results of the restore
// request.
type S3Location struct {

	// The name of the bucket where the restore results will be placed.
	//
	// This member is required.
	BucketName *string

	// The prefix that is prepended to the restore results for this request.
	//
	// This member is required.
	Prefix *string

	// A list of grants that control access to the staged results.
	AccessControlList []Grant

	// The canned ACL to apply to the restore results.
	CannedACL ObjectCannedACL

	// Contains the type of server-side encryption used.
	Encryption *Encryption

	// The class of storage used to store the restore results.
	StorageClass StorageClass

	// The tag-set that is applied to the restore results.
	Tagging *Tagging

	// A list of metadata to store with the restore results in S3.
	UserMetadata []MetadataEntry
}

// Describes the parameters for Select job types.
type SelectParameters struct {

	// The expression that is used to query the object.
	//
	// This member is required.
	Expression *string

	// The type of the provided expression (for example, SQL).
	//
	// This member is required.
	ExpressionType ExpressionType

	// Describes the serialization format of the object.
	//
	// This member is required.
	InputSerialization *InputSerialization

	// Describes how the results of the Select job are serialized.
	//
	// This member is required.
	OutputSerialization *OutputSerialization
}

// Describes the default server-side encryption to apply to new objects in the
// bucket. If a PUT Object request doesn't specify any server-side encryption, this
// default encryption will be applied. For more information, see PUT Bucket
// encryption
// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html)
// in the Amazon Simple Storage Service API Reference.
type ServerSideEncryptionByDefault struct {

	// Server-side encryption algorithm to use for the default encryption.
	//
	// This member is required.
	SSEAlgorithm ServerSideEncryption

	// AWS Key Management Service (KMS) customer master key ID to use for the default
	// encryption. This parameter is allowed if and only if SSEAlgorithm is set to
	// aws:kms. You can specify the key ID or the Amazon Resource Name (ARN) of the
	// CMK. However, if you are using encryption with cross-account operations, you
	// must use a fully qualified CMK ARN. For more information, see Using encryption
	// for cross-account operations
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy).
	// For example:
	//
	// * Key ID: 1234abcd-12ab-34cd-56ef-1234567890ab
	//
	// * Key ARN:
	// arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
	//
	// Amazon
	// S3 only supports symmetric CMKs and not asymmetric CMKs. For more information,
	// see Using Symmetric and Asymmetric Keys
	// (https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html)
	// in the AWS Key Management Service Developer Guide.
	KMSMasterKeyID *string
}

// Specifies the default server-side-encryption configuration.
type ServerSideEncryptionConfiguration struct {

	// Container for information about a particular server-side encryption
	// configuration rule.
	//
	// This member is required.
	Rules []ServerSideEncryptionRule
}

// Specifies the default server-side encryption configuration.
type ServerSideEncryptionRule struct {

	// Specifies the default server-side encryption to apply to new objects in the
	// bucket. If a PUT Object request doesn't specify any server-side encryption, this
	// default encryption will be applied.
	ApplyServerSideEncryptionByDefault *ServerSideEncryptionByDefault

	// Specifies whether Amazon S3 should use an S3 Bucket Key with server-side
	// encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects
	// are not affected. Setting the BucketKeyEnabled element to true causes Amazon S3
	// to use an S3 Bucket Key. By default, S3 Bucket Key is not enabled. For more
	// information, see Amazon S3 Bucket Keys
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html) in the Amazon
	// Simple Storage Service Developer Guide.
	BucketKeyEnabled bool
}

// A container that describes additional filters for identifying the source objects
// that you want to replicate. You can choose to enable or disable the replication
// of these objects. Currently, Amazon S3 supports only the filter that you can
// specify for objects created with server-side encryption using a customer master
// key (CMK) stored in AWS Key Management Service (SSE-KMS).
type SourceSelectionCriteria struct {

	// A filter that you can specify for selections for modifications on replicas.
	// Amazon S3 doesn't replicate replica modifications by default. In the latest
	// version of replication configuration (when Filter is specified), you can specify
	// this element and set the status to Enabled to replicate modifications on
	// replicas. If you don't specify the Filter element, Amazon S3 assumes that the
	// replication configuration is the earlier version, V1. In the earlier version,
	// this element is not allowed
	ReplicaModifications *ReplicaModifications

	// A container for filter information for the selection of Amazon S3 objects
	// encrypted with AWS KMS. If you include SourceSelectionCriteria in the
	// replication configuration, this element is required.
	SseKmsEncryptedObjects *SseKmsEncryptedObjects
}

// Specifies the use of SSE-KMS to encrypt delivered inventory reports.
type SSEKMS struct {

	// Specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer
	// managed customer master key (CMK) to use for encrypting inventory reports.
	//
	// This member is required.
	KeyId *string
}

// A container for filter information for the selection of S3 objects encrypted
// with AWS KMS.
type SseKmsEncryptedObjects struct {

	// Specifies whether Amazon S3 replicates objects created with server-side
	// encryption using a customer master key (CMK) stored in AWS Key Management
	// Service.
	//
	// This member is required.
	Status SseKmsEncryptedObjectsStatus
}

// Specifies the use of SSE-S3 to encrypt delivered inventory reports.
type SSES3 struct {
}

// Specifies data related to access patterns to be collected and made available to
// analyze the tradeoffs between different storage classes for an Amazon S3 bucket.
type StorageClassAnalysis struct {

	// Specifies how data related to the storage class analysis for an Amazon S3 bucket
	// should be exported.
	DataExport *StorageClassAnalysisDataExport
}

// Container for data related to the storage class analysis for an Amazon S3 bucket
// for export.
type StorageClassAnalysisDataExport struct {

	// The place to store the data for an analysis.
	//
	// This member is required.
	Destination *AnalyticsExportDestination

	// The version of the output schema to use when exporting data. Must be V_1.
	//
	// This member is required.
	OutputSchemaVersion StorageClassAnalysisSchemaVersion
}

// A container of a key value name pair.
type Tag struct {

	// Name of the object key.
	//
	// This member is required.
	Key *string

	// Value of the tag.
	//
	// This member is required.
	Value *string
}

// Container for TagSet elements.
type Tagging struct {

	// A collection for a set of tags
	//
	// This member is required.
	TagSet []Tag
}

// Container for granting information.
type TargetGrant struct {

	// Container for the person being granted permissions.
	Grantee *Grantee

	// Logging permissions assigned to the grantee for the bucket.
	Permission BucketLogsPermission
}

// The S3 Intelligent-Tiering storage class is designed to optimize storage costs
// by automatically moving data to the most cost-effective storage access tier,
// without additional operational overhead.
type Tiering struct {

	// S3 Intelligent-Tiering access tier. See Storage class for automatically
	// optimizing frequently and infrequently accessed objects
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html#sc-dynamic-data-access)
	// for a list of access tiers in the S3 Intelligent-Tiering storage class.
	//
	// This member is required.
	AccessTier IntelligentTieringAccessTier

	// The number of consecutive days of no access after which an object will be
	// eligible to be transitioned to the corresponding tier. The minimum number of
	// days specified for Archive Access tier must be at least 90 days and Deep Archive
	// Access tier must be at least 180 days. The maximum can be up to 2 years (730
	// days).
	//
	// This member is required.
	Days int32
}

// A container for specifying the configuration for publication of messages to an
// Amazon Simple Notification Service (Amazon SNS) topic when Amazon S3 detects
// specified events.
type TopicConfiguration struct {

	// The Amazon S3 bucket event about which to send notifications. For more
	// information, see Supported Event Types
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	//
	// This member is required.
	Events []Event

	// The Amazon Resource Name (ARN) of the Amazon SNS topic to which Amazon S3
	// publishes a message when it detects events of the specified type.
	//
	// This member is required.
	TopicArn *string

	// Specifies object key name filtering rules. For information about key name
	// filtering, see Configuring Event Notifications
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html) in the
	// Amazon Simple Storage Service Developer Guide.
	Filter *NotificationConfigurationFilter

	// An optional unique identifier for configurations in a notification
	// configuration. If you don't provide one, Amazon S3 will assign an ID.
	Id *string
}

// Specifies when an object transitions to a specified storage class. For more
// information about Amazon S3 lifecycle configuration rules, see Transitioning
// Objects Using Amazon S3 Lifecycle
// (https://docs.aws.amazon.com/AmazonS3/latest/dev/lifecycle-transition-general-considerations.html)
// in the Amazon Simple Storage Service Developer Guide.
type Transition struct {

	// Indicates when objects are transitioned to the specified storage class. The date
	// value must be in ISO 8601 format. The time is always midnight UTC.
	Date *time.Time

	// Indicates the number of days after creation when objects are transitioned to the
	// specified storage class. The value must be a positive integer.
	Days int32

	// The storage class to which you want the object to transition.
	StorageClass TransitionStorageClass
}

// Describes the versioning state of an Amazon S3 bucket. For more information, see
// PUT Bucket versioning
// (https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTVersioningStatus.html)
// in the Amazon Simple Storage Service API Reference.
type VersioningConfiguration struct {

	// Specifies whether MFA delete is enabled in the bucket versioning configuration.
	// This element is only returned if the bucket has been configured with MFA delete.
	// If the bucket has never been so configured, this element is not returned.
	MFADelete MFADelete

	// The versioning state of the bucket.
	Status BucketVersioningStatus
}

// Specifies website configuration parameters for an Amazon S3 bucket.
type WebsiteConfiguration struct {

	// The name of the error document for the website.
	ErrorDocument *ErrorDocument

	// The name of the index document for the website.
	IndexDocument *IndexDocument

	// The redirect behavior for every request to this bucket's website endpoint. If
	// you specify this property, you can't specify any other property.
	RedirectAllRequestsTo *RedirectAllRequestsTo

	// Rules that define when a redirect is applied and the redirect behavior.
	RoutingRules []RoutingRule
}

// UnknownUnionMember is returned when a union member is returned over the wire,
// but has an unknown tag.
type UnknownUnionMember struct {
	Tag   string
	Value []byte
}

func (*UnknownUnionMember) isAnalyticsFilter()       {}
func (*UnknownUnionMember) isLifecycleRuleFilter()   {}
func (*UnknownUnionMember) isMetricsFilter()         {}
func (*UnknownUnionMember) isReplicationRuleFilter() {}