type AbortIncompleteMultipartUpload struct {
	// Specifies the number of days after which Amazon S3 aborts an incomplete
	// multipart upload.
	DaysAfterInitiation *int32
}

type AccelerateConfiguration struct {
	// Specifies the transfer acceleration status of the bucket.
	Status BucketAccelerateStatus
}

type AccessControlPolicy struct {
	// A list of grants.
	Grants []*Grant
	// Container for the bucket owner's display name and ID.
	Owner *Owner
}

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.
	Owner OwnerOverride
}

type AnalyticsAndOperator struct {
	// The list of tags to use when evaluating an AND predicate.
	Tags []*Tag
	// 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
}

type AnalyticsConfiguration struct {
	// Contains data related to access patterns to be collected and made available to
	// analyze the tradeoffs between different storage classes.
	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
	// The ID that identifies the analytics configuration.
	Id *string
}

type AnalyticsExportDestination struct {
	// A destination signifying output to an S3 bucket.
	S3BucketDestination *AnalyticsS3BucketDestination
}

type AnalyticsFilter struct {
	// A conjunction (logical AND) of predicates, which is used in evaluating an
	// analytics filter. The operator must have at least two predicates.
	And *AnalyticsAndOperator
	// The prefix to use when evaluating an analytics filter.
	Prefix *string
	// The tag to use when evaluating an analytics filter.
	Tag *Tag
}

type AnalyticsS3BucketDestination struct {
	// Specifies the file format used when exporting data to Amazon S3.
	Format AnalyticsS3ExportFileFormat
	// The prefix to use when exporting data. The prefix is prepended to all results.
	Prefix *string
	// The Amazon Resource Name (ARN) of the bucket to which data is exported.
	Bucket *string
	// 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
}

type AnalyticsS3ExportFileFormat string

const (
	AnalyticsS3ExportFileFormatCsv AnalyticsS3ExportFileFormat = "CSV"
)

type Bucket struct {
	// Date the bucket was created.
	CreationDate *time.Time
	// The name of the bucket.
	Name *string
}

type BucketAccelerateStatus string

const (
	BucketAccelerateStatusEnabled   BucketAccelerateStatus = "Enabled"
	BucketAccelerateStatusSuspended BucketAccelerateStatus = "Suspended"
)

type BucketAlreadyExists struct {
	Message *string
}

type BucketAlreadyOwnedByYou struct {
	Message *string
}

type BucketCannedACL string

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

type BucketLifecycleConfiguration struct {
	// A lifecycle rule for individual objects in an Amazon S3 bucket.
	Rules []*LifecycleRule
}

type BucketLocationConstraint string

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

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
}

type BucketLogsPermission string

const (
	BucketLogsPermissionFull_control BucketLogsPermission = "FULL_CONTROL"
	BucketLogsPermissionRead         BucketLogsPermission = "READ"
	BucketLogsPermissionWrite        BucketLogsPermission = "WRITE"
)

type BucketVersioningStatus string

const (
	BucketVersioningStatusEnabled   BucketVersioningStatus = "Enabled"
	BucketVersioningStatusSuspended BucketVersioningStatus = "Suspended"
)

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.
	CORSRules []*CORSRule
}

type CORSRule struct {
	// The time in seconds that your browser is to cache the preflight response for the
	// specified resource.
	MaxAgeSeconds *int32
	// One or more origins you want customers to be able to access the bucket from.
	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
	// An HTTP method that you allow the origin to execute. Valid values are GET, PUT,
	// HEAD, POST, and DELETE.
	AllowedMethods []*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
}

type CSVInput struct {
	// 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 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
	// 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 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 ". 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
}

type CSVOutput struct {
	// The single character used for escaping the quote character inside an already
	// escaped value.
	QuoteEscapeCharacter *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
	// A single character used to separate individual records in the output. Instead of
	// the default value, you can specify an arbitrary delimiter.
	RecordDelimiter *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
	// The value used to separate individual fields in a record. You can specify an
	// arbitrary delimiter.
	FieldDelimiter *string
}

type CommonPrefix struct {
	// Container for the specified common prefix.
	Prefix *string
}

type CompletedMultipartUpload struct {
	// Array of CompletedPart data types.
	Parts []*CompletedPart
}

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
}

type CompressionType string

const (
	CompressionTypeNone  CompressionType = "NONE"
	CompressionTypeGzip  CompressionType = "GZIP"
	CompressionTypeBzip2 CompressionType = "BZIP2"
)

type Condition struct {
	// 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
	// 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
}

type CopyObjectResult struct {
	// Returns the date that the object was last modified.
	LastModified *time.Time
	// 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
}

type CopyPartResult struct {
	// Entity tag of the object.
	ETag *string
	// Date and time at which the object was uploaded.
	LastModified *time.Time
}

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
}

type DefaultRetention struct {
	// The default Object Lock retention mode you want to apply to new objects placed
	// in the specified bucket.
	Mode ObjectLockRetentionMode
	// The number of days that you want to specify for the default retention period.
	Days *int32
	// The number of years that you want to specify for the default retention period.
	Years *int32
}

type Delete struct {
	// The objects to delete.
	Objects []*ObjectIdentifier
	// Element to enable quiet mode for the request. When you add this element, you
	// must set its value to true.
	Quiet *bool
}

type DeleteMarkerEntry struct {
	// Version ID of an object.
	VersionId *string
	// Date and time the object was last modified.
	LastModified *time.Time
	// The account that created the delete marker.>
	Owner *Owner
	// Specifies whether the object is (true) or is not (false) the latest version of
	// an object.
	IsLatest *bool
	// The object key.
	Key *string
}

type DeleteMarkerReplication struct {
	// Indicates whether to replicate delete markers. In the current implementation,
	// Amazon S3 doesn't replicate the delete markers. The status must be Disabled.
	Status DeleteMarkerReplicationStatus
}

type DeleteMarkerReplicationStatus string

const (
	DeleteMarkerReplicationStatusEnabled  DeleteMarkerReplicationStatus = "Enabled"
	DeleteMarkerReplicationStatusDisabled DeleteMarkerReplicationStatus = "Disabled"
)

type DeletedObject struct {
	// The name of the deleted object.
	Key *string
	// 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
	// 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 deleted object.
	VersionId *string
}

type Destination struct {
	// 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
	// A container specifying replication metrics-related settings enabling metrics and
	// Amazon S3 events for S3 Replication Time Control (S3 RTC). Must be specified
	// together with a ReplicationTime block.
	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
	// 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
	// The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to store
	// the results.
	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
}

type EncodingType string

const (
	EncodingTypeUrl EncodingType = "url"
)

type Encryption struct {
	// 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
	// The server-side encryption algorithm used when storing job results in Amazon S3
	// (for example, AES256, aws:kms).
	EncryptionType ServerSideEncryption
}

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
}

type Error struct {
	// The error key.
	Key *string
	// 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 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
}

type ErrorDocument struct {
	// The object key name to use when a 4XX class error occurs.
	Key *string
}

type Event string

const (
	EventS3Reducedredundancylostobject                  Event = "s3:ReducedRedundancyLostObject"
	EventS3Objectcreated                                Event = "s3:ObjectCreated:*"
	EventS3ObjectcreatedPut                             Event = "s3:ObjectCreated:Put"
	EventS3ObjectcreatedPost                            Event = "s3:ObjectCreated:Post"
	EventS3ObjectcreatedCopy                            Event = "s3:ObjectCreated:Copy"
	EventS3ObjectcreatedCompletemultipartupload         Event = "s3:ObjectCreated:CompleteMultipartUpload"
	EventS3Objectremoved                                Event = "s3:ObjectRemoved:*"
	EventS3ObjectremovedDelete                          Event = "s3:ObjectRemoved:Delete"
	EventS3ObjectremovedDeletemarkercreated             Event = "s3:ObjectRemoved:DeleteMarkerCreated"
	EventS3Objectrestore                                Event = "s3:ObjectRestore:*"
	EventS3ObjectrestorePost                            Event = "s3:ObjectRestore:Post"
	EventS3ObjectrestoreCompleted                       Event = "s3:ObjectRestore:Completed"
	EventS3Replication                                  Event = "s3:Replication:*"
	EventS3ReplicationOperationfailedreplication        Event = "s3:Replication:OperationFailedReplication"
	EventS3ReplicationOperationnottracked               Event = "s3:Replication:OperationNotTracked"
	EventS3ReplicationOperationmissedthreshold          Event = "s3:Replication:OperationMissedThreshold"
	EventS3ReplicationOperationreplicatedafterthreshold Event = "s3:Replication:OperationReplicatedAfterThreshold"
)

type ExistingObjectReplication struct {
	//
	Status ExistingObjectReplicationStatus
}

type ExistingObjectReplicationStatus string

const (
	ExistingObjectReplicationStatusEnabled  ExistingObjectReplicationStatus = "Enabled"
	ExistingObjectReplicationStatusDisabled ExistingObjectReplicationStatus = "Disabled"
)

type ExpirationStatus string

const (
	ExpirationStatusEnabled  ExpirationStatus = "Enabled"
	ExpirationStatusDisabled ExpirationStatus = "Disabled"
)

type ExpressionType string

const (
	ExpressionTypeSql ExpressionType = "SQL"
)

type FileHeaderInfo string

const (
	FileHeaderInfoUse    FileHeaderInfo = "USE"
	FileHeaderInfoIgnore FileHeaderInfo = "IGNORE"
	FileHeaderInfoNone   FileHeaderInfo = "NONE"
)

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
}

type FilterRuleName string

const (
	FilterRuleNamePrefix FilterRuleName = "prefix"
	FilterRuleNameSuffix FilterRuleName = "suffix"
)

type GlacierJobParameters struct {
	// S3 Glacier retrieval tier at which the restore will be processed.
	Tier Tier
}

type Grant struct {
	// Specifies the permission given to the grantee.
	Permission Permission
	// The person being granted permissions.
	Grantee *Grantee
}

type Grantee struct {
	// The canonical user ID of the grantee.
	ID *string
	// 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
	// URI of the grantee group.
	URI *string
	// Type of grantee
	Type Type
}

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.
	Suffix *string
}

type Initiator struct {
	// 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
	// Name of the Principal.
	DisplayName *string
}

type InputSerialization struct {
	// Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default
	// Value: NONE.
	CompressionType CompressionType
	// Specifies Parquet as object's input serialization format.
	Parquet *ParquetInput
	// Describes the serialization of a CSV-encoded object.
	CSV *CSVInput
	// Specifies JSON as object's input serialization format.
	JSON *JSONInput
}

type InventoryConfiguration struct {
	// Contains the optional fields that are included in the inventory results.
	OptionalFields []InventoryOptionalField
	// Contains information about where to publish the inventory results.
	Destination *InventoryDestination
	// The ID used to identify the inventory configuration.
	Id *string
	// Specifies an inventory filter. The inventory only includes objects that meet the
	// filter's criteria.
	Filter *InventoryFilter
	// Specifies the schedule for generating inventory results.
	Schedule *InventorySchedule
	// 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.
	IsEnabled *bool
	// 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.
	IncludedObjectVersions InventoryIncludedObjectVersions
}

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

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

type InventoryFilter struct {
	// The prefix that an object must have to be included in the inventory results.
	Prefix *string
}

type InventoryFormat string

const (
	InventoryFormatCsv     InventoryFormat = "CSV"
	InventoryFormatOrc     InventoryFormat = "ORC"
	InventoryFormatParquet InventoryFormat = "Parquet"
)

type InventoryFrequency string

const (
	InventoryFrequencyDaily  InventoryFrequency = "Daily"
	InventoryFrequencyWeekly InventoryFrequency = "Weekly"
)

type InventoryIncludedObjectVersions string

const (
	InventoryIncludedObjectVersionsAll     InventoryIncludedObjectVersions = "All"
	InventoryIncludedObjectVersionsCurrent InventoryIncludedObjectVersions = "Current"
)

type InventoryOptionalField string

const (
	InventoryOptionalFieldSize                         InventoryOptionalField = "Size"
	InventoryOptionalFieldLastmodifieddate             InventoryOptionalField = "LastModifiedDate"
	InventoryOptionalFieldStorageclass                 InventoryOptionalField = "StorageClass"
	InventoryOptionalFieldEtag                         InventoryOptionalField = "ETag"
	InventoryOptionalFieldIsmultipartuploaded          InventoryOptionalField = "IsMultipartUploaded"
	InventoryOptionalFieldReplicationstatus            InventoryOptionalField = "ReplicationStatus"
	InventoryOptionalFieldEncryptionstatus             InventoryOptionalField = "EncryptionStatus"
	InventoryOptionalFieldObjectlockretainuntildate    InventoryOptionalField = "ObjectLockRetainUntilDate"
	InventoryOptionalFieldObjectlockmode               InventoryOptionalField = "ObjectLockMode"
	InventoryOptionalFieldObjectlocklegalholdstatus    InventoryOptionalField = "ObjectLockLegalHoldStatus"
	InventoryOptionalFieldIntelligenttieringaccesstier InventoryOptionalField = "IntelligentTieringAccessTier"
)

type InventoryS3BucketDestination struct {
	// The Amazon Resource Name (ARN) of the bucket where inventory results will be
	// published.
	Bucket *string
	// 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 output format of the inventory results.
	Format InventoryFormat
}

type InventorySchedule struct {
	// Specifies how frequently inventory results are produced.
	Frequency InventoryFrequency
}

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

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
}

type JSONType string

const (
	JSONTypeDocument JSONType = "DOCUMENT"
	JSONTypeLines    JSONType = "LINES"
)

type LambdaFunctionConfiguration struct {
	// The Amazon Resource Name (ARN) of the AWS Lambda function that Amazon S3 invokes
	// when the specified event type occurs.
	LambdaFunctionArn *string
	// An optional unique identifier for configurations in a notification
	// configuration. If you don't provide one, Amazon S3 will assign an ID.
	Id *string
	// 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.
	Events []Event
	// 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
}

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

type LifecycleRule struct {
	// Unique identifier for the rule. The value cannot be longer than 255 characters.
	ID *string
	// If 'Enabled', the rule is currently being applied. If 'Disabled', the rule is
	// not currently being applied.
	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 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.
	Prefix *string
	// Specifies when an Amazon S3 object transitions to a specified storage class.
	Transitions []*Transition
	// 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
	// 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
	// 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
}

type LifecycleRuleAndOperator struct {
	// All of these tags must exist in the object's tag set in order for the rule to
	// apply.
	Tags []*Tag
	// Prefix identifying one or more objects to which the rule applies.
	Prefix *string
}

type LifecycleRuleFilter struct {
	// 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.
	And *LifecycleRuleAndOperator
	// Prefix identifying one or more objects to which the rule applies.
	Prefix *string
	// This tag must exist in the object's tag set in order for the rule to apply.
	Tag *Tag
}

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.
	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.
	TargetPrefix *string
	// Container for granting information.
	TargetGrants []*TargetGrant
}

type MFADelete string

const (
	MFADeleteEnabled  MFADelete = "Enabled"
	MFADeleteDisabled MFADelete = "Disabled"
)

type MFADeleteStatus string

const (
	MFADeleteStatusEnabled  MFADeleteStatus = "Enabled"
	MFADeleteStatusDisabled MFADeleteStatus = "Disabled"
)

type MetadataDirective string

const (
	MetadataDirectiveCopy    MetadataDirective = "COPY"
	MetadataDirectiveReplace MetadataDirective = "REPLACE"
)

type MetadataEntry struct {
	// Name of the Object.
	Name *string
	// Value of the Object.
	Value *string
}

type Metrics struct {
	// A container specifying the time threshold for emitting the
	// s3:Replication:OperationMissedThreshold event.
	EventThreshold *ReplicationTimeValue
	// Specifies whether the replication metrics are enabled.
	Status MetricsStatus
}

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
}

type MetricsConfiguration struct {
	// 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
	// The ID used to identify the metrics configuration.
	Id *string
}

type MetricsFilter struct {
	// The prefix used when evaluating a metrics filter.
	Prefix *string
	// 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 *MetricsAndOperator
	// The tag used when evaluating a metrics filter.
	Tag *Tag
}

type MetricsStatus string

const (
	MetricsStatusEnabled  MetricsStatus = "Enabled"
	MetricsStatusDisabled MetricsStatus = "Disabled"
)

type MultipartUpload struct {
	// Key of the object for which the multipart upload was initiated.
	Key *string
	// Upload ID that identifies the multipart upload.
	UploadId *string
	// Date and time at which the multipart upload was initiated.
	Initiated *time.Time
	// Specifies the owner of the object that is part of the multipart upload.
	Owner *Owner
	// Identifies who initiated the multipart upload.
	Initiator *Initiator
	// The class of storage used to store the object.
	StorageClass StorageClass
}

type NoSuchBucket struct {
	Message *string
}

type NoSuchKey struct {
	Message *string
}

type NoSuchUpload struct {
	Message *string
}

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
}

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
}

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
}

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

type Object struct {
	// The owner of the object
	Owner *Owner
	// The class of storage used to store the object.
	StorageClass ObjectStorageClass
	// The date the Object was Last Modified
	LastModified *time.Time
	// The entity tag is an MD5 hash of the object. ETag reflects only changes to the
	// contents of an object, not its metadata.
	ETag *string
	// Size in bytes of the object
	Size *int64
	// The name that you assign to an object. You use the object key to retrieve the
	// object.
	Key *string
}

type ObjectAlreadyInActiveTierError struct {
	Message *string
}

type ObjectCannedACL string

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

type ObjectIdentifier struct {
	// Key name of the object to delete.
	Key *string
	// VersionId for the specific version of the object to delete.
	VersionId *string
}

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
}

type ObjectLockEnabled string

const (
	ObjectLockEnabledEnabled ObjectLockEnabled = "Enabled"
)

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

type ObjectLockLegalHoldStatus string

const (
	ObjectLockLegalHoldStatusOn  ObjectLockLegalHoldStatus = "ON"
	ObjectLockLegalHoldStatusOff ObjectLockLegalHoldStatus = "OFF"
)

type ObjectLockMode string

const (
	ObjectLockModeGovernance ObjectLockMode = "GOVERNANCE"
	ObjectLockModeCompliance ObjectLockMode = "COMPLIANCE"
)

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
}

type ObjectLockRetentionMode string

const (
	ObjectLockRetentionModeGovernance ObjectLockRetentionMode = "GOVERNANCE"
	ObjectLockRetentionModeCompliance ObjectLockRetentionMode = "COMPLIANCE"
)

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

type ObjectNotInActiveTierError struct {
	Message *string
}

type ObjectStorageClass string

const (
	ObjectStorageClassStandard            ObjectStorageClass = "STANDARD"
	ObjectStorageClassReduced_redundancy  ObjectStorageClass = "REDUCED_REDUNDANCY"
	ObjectStorageClassGlacier             ObjectStorageClass = "GLACIER"
	ObjectStorageClassStandard_ia         ObjectStorageClass = "STANDARD_IA"
	ObjectStorageClassOnezone_ia          ObjectStorageClass = "ONEZONE_IA"
	ObjectStorageClassIntelligent_tiering ObjectStorageClass = "INTELLIGENT_TIERING"
	ObjectStorageClassDeep_archive        ObjectStorageClass = "DEEP_ARCHIVE"
)

type ObjectVersion struct {
	// The class of storage used to store the object.
	StorageClass ObjectVersionStorageClass
	// Specifies whether the object is (true) or is not (false) the latest version of
	// an object.
	IsLatest *bool
	// Specifies the owner of the object.
	Owner *Owner
	// The entity tag is an MD5 hash of that version of the object.
	ETag *string
	// Version ID of an object.
	VersionId *string
	// Size in bytes of the object.
	Size *int64
	// The object key.
	Key *string
	// Date and time the object was last modified.
	LastModified *time.Time
}

type ObjectVersionStorageClass string

const (
	ObjectVersionStorageClassStandard ObjectVersionStorageClass = "STANDARD"
)

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

type OutputSerialization struct {
	// Describes the serialization of CSV-encoded Select results.
	CSV *CSVOutput
	// Specifies JSON as request's output serialization format.
	JSON *JSONOutput
}

type Owner struct {
	// Container for the display name of the owner.
	DisplayName *string
	// Container for the ID of the owner.
	ID *string
}

type OwnerOverride string

const (
	OwnerOverrideDestination OwnerOverride = "Destination"
)

type ParquetInput struct {
}

type Part struct {
	// Entity tag returned when the part was uploaded.
	ETag *string
	// Part number identifying the part. This is a positive integer between 1 and
	// 10,000.
	PartNumber *int32
	// Date and time at which the part was uploaded.
	LastModified *time.Time
	// Size in bytes of the uploaded part data.
	Size *int64
}

type Payer string

const (
	PayerRequester   Payer = "Requester"
	PayerBucketowner Payer = "BucketOwner"
)

type Permission string

const (
	PermissionFull_control Permission = "FULL_CONTROL"
	PermissionWrite        Permission = "WRITE"
	PermissionWrite_acp    Permission = "WRITE_ACP"
	PermissionRead         Permission = "READ"
	PermissionRead_acp     Permission = "READ_ACP"
)

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
}

type Protocol string

const (
	ProtocolHttp  Protocol = "http"
	ProtocolHttps Protocol = "https"
)

type PublicAccessBlockConfiguration struct {
	// 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
	// services 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 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 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 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
}

type QueueConfiguration struct {
	// An optional unique identifier for configurations in a notification
	// configuration. If you don't provide one, Amazon S3 will assign an ID.
	Id *string
	// A collection of bucket events for which to send notifications
	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.
	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
}

type QuoteFields string

const (
	QuoteFieldsAlways   QuoteFields = "ALWAYS"
	QuoteFieldsAsneeded QuoteFields = "ASNEEDED"
)

type Redirect struct {
	// Protocol to use when redirecting requests. The default is the protocol that is
	// used in the original request.
	Protocol Protocol
	// 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
	// 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 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
}

type RedirectAllRequestsTo struct {
	// Protocol to use when redirecting requests. The default is the protocol that is
	// used in the original request.
	Protocol Protocol
	// Name of the host where requests are redirected.
	HostName *string
}

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.
	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.
	Rules []*ReplicationRule
}

type ReplicationRule struct {
	// Specifies whether the rule is enabled.
	Status ReplicationRuleStatus
	// The priority associated with the rule. If you specify multiple rules in a
	// replication configuration, Amazon S3 prioritizes the rules to prevent conflicts
	// when filtering. If two or more rules identify the same object based on a
	// specified filter, the rule with higher priority takes precedence. For example:
	//
	//
	// * Same object quality prefix-based filter criteria if prefixes you specified in
	// multiple rules overlap
	//
	//     * Same object qualify tag-based filter criteria
	// specified in multiple rules
	//
	// 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 for information about the replication destination and its
	// configurations including enabling the S3 Replication Time Control (S3 RTC).
	Destination *Destination
	// A unique identifier for the rule. The maximum value is 255 characters.
	ID *string
	// 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
	// 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.
	Prefix *string
	// 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
	//
	ExistingObjectReplication *ExistingObjectReplication
	// Specifies whether Amazon S3 replicates the delete markers. If you specify a
	// Filter, you must specify this element. However, in the latest version of
	// replication configuration (when Filter is specified), Amazon S3 doesn't
	// replicate delete markers. Therefore, the DeleteMarkerReplication element can
	// contain only Disabled. 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).
	// <note> <p> If you don't specify the <code>Filter</code> element, Amazon S3
	// assumes that the replication configuration is the earlier version, V1. In the
	// earlier version, Amazon S3 handled replication of delete markers differently.
	// For more information, see <a
	// href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-backward-compat-considerations">Backward
	// Compatibility</a>.</p> </note>
	DeleteMarkerReplication *DeleteMarkerReplication
}

type ReplicationRuleAndOperator struct {
	// An array of tags containing key and value pairs.
	Tags []*Tag
	// An object key name prefix that identifies the subset of objects to which the
	// rule applies.
	Prefix *string
}

type ReplicationRuleFilter struct {
	// 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.
	And *ReplicationRuleAndOperator
	// An object key name prefix that identifies the subset of objects to which the
	// rule applies.
	Prefix *string
	// A container for specifying a tag key and value. The rule applies only to objects
	// that have the tag in their tag set.
	Tag *Tag
}

type ReplicationRuleStatus string

const (
	ReplicationRuleStatusEnabled  ReplicationRuleStatus = "Enabled"
	ReplicationRuleStatusDisabled ReplicationRuleStatus = "Disabled"
)

type ReplicationStatus string

const (
	ReplicationStatusComplete ReplicationStatus = "COMPLETE"
	ReplicationStatusPending  ReplicationStatus = "PENDING"
	ReplicationStatusFailed   ReplicationStatus = "FAILED"
	ReplicationStatusReplica  ReplicationStatus = "REPLICA"
)

type ReplicationTime struct {
	// Specifies whether the replication time is enabled.
	Status ReplicationTimeStatus
	// A container specifying the time by which replication should be complete for all
	// objects and operations on objects.
	Time *ReplicationTimeValue
}

type ReplicationTimeStatus string

const (
	ReplicationTimeStatusEnabled  ReplicationTimeStatus = "Enabled"
	ReplicationTimeStatusDisabled ReplicationTimeStatus = "Disabled"
)

type ReplicationTimeValue struct {
	// Contains an integer specifying time in minutes. Valid values: 15 minutes.
	Minutes *int32
}

type RequestCharged string

const (
	RequestChargedRequester RequestCharged = "requester"
)

type RequestPayer string

const (
	RequestPayerRequester RequestPayer = "requester"
)

type RequestPaymentConfiguration struct {
	// Specifies who pays for the download and request fees.
	Payer Payer
}

type RestoreRequest struct {
	// 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
	// S3 Glacier retrieval tier at which the restore will be processed.
	Tier Tier
	// Lifetime of the active copy in days. Do not use with restores that specify
	// OutputLocation.
	Days *int32
	// Describes the location where the restore job's output is stored.
	OutputLocation *OutputLocation
	// Describes the parameters for Select job types.
	SelectParameters *SelectParameters
	// Type of restore request.
	Type RestoreRequestType
}

type RestoreRequestType string

const (
	RestoreRequestTypeSelect RestoreRequestType = "SELECT"
)

type RoutingRule struct {
	// 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
	// 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.
	Redirect *Redirect
}

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

type S3Location struct {
	// A list of metadata to store with the restore results in S3.
	UserMetadata []*MetadataEntry
	// The class of storage used to store the restore results.
	StorageClass StorageClass
	// The canned ACL to apply to the restore results.
	CannedACL ObjectCannedACL
	// Contains the type of server-side encryption used.
	Encryption *Encryption
	// The prefix that is prepended to the restore results for this request.
	Prefix *string
	// The name of the bucket where the restore results will be placed.
	BucketName *string
	// A list of grants that control access to the staged results.
	AccessControlList []*Grant
	// The tag-set that is applied to the restore results.
	Tagging *Tagging
}

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.
	KeyId *string
}

type SSES3 struct {
}

type SelectParameters struct {
	// The expression that is used to query the object.
	Expression *string
	// Describes the serialization format of the object.
	InputSerialization *InputSerialization
	// The type of the provided expression (for example, SQL).
	ExpressionType ExpressionType
	// Describes how the results of the Select job are serialized.
	OutputSerialization *OutputSerialization
}

type ServerSideEncryption string

const (
	ServerSideEncryptionAes256 ServerSideEncryption = "AES256"
	ServerSideEncryptionAwsKms ServerSideEncryption = "aws:kms"
)

type ServerSideEncryptionByDefault struct {
	// 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
	// Server-side encryption algorithm to use for the default encryption.
	SSEAlgorithm ServerSideEncryption
}

type ServerSideEncryptionConfiguration struct {
	// Container for information about a particular server-side encryption
	// configuration rule.
	Rules []*ServerSideEncryptionRule
}

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
}

type SourceSelectionCriteria struct {
	// 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
}

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.
	Status SseKmsEncryptedObjectsStatus
}

type SseKmsEncryptedObjectsStatus string

const (
	SseKmsEncryptedObjectsStatusEnabled  SseKmsEncryptedObjectsStatus = "Enabled"
	SseKmsEncryptedObjectsStatusDisabled SseKmsEncryptedObjectsStatus = "Disabled"
)

type StorageClass string

const (
	StorageClassStandard            StorageClass = "STANDARD"
	StorageClassReduced_redundancy  StorageClass = "REDUCED_REDUNDANCY"
	StorageClassStandard_ia         StorageClass = "STANDARD_IA"
	StorageClassOnezone_ia          StorageClass = "ONEZONE_IA"
	StorageClassIntelligent_tiering StorageClass = "INTELLIGENT_TIERING"
	StorageClassGlacier             StorageClass = "GLACIER"
	StorageClassDeep_archive        StorageClass = "DEEP_ARCHIVE"
)

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

type StorageClassAnalysisDataExport struct {
	// The place to store the data for an analysis.
	Destination *AnalyticsExportDestination
	// The version of the output schema to use when exporting data. Must be V_1.
	OutputSchemaVersion StorageClassAnalysisSchemaVersion
}

type StorageClassAnalysisSchemaVersion string

const (
	StorageClassAnalysisSchemaVersionV_1 StorageClassAnalysisSchemaVersion = "V_1"
)

type Tag struct {
	// Name of the tag.
	Key *string
	// Value of the tag.
	Value *string
}

type Tagging struct {
	// A collection for a set of tags
	TagSet []*Tag
}

type TaggingDirective string

const (
	TaggingDirectiveCopy    TaggingDirective = "COPY"
	TaggingDirectiveReplace TaggingDirective = "REPLACE"
)

type TargetGrant struct {
	// Container for the person being granted permissions.
	Grantee *Grantee
	// Logging permissions assigned to the Grantee for the bucket.
	Permission BucketLogsPermission
}

type Tier string

const (
	TierStandard  Tier = "Standard"
	TierBulk      Tier = "Bulk"
	TierExpedited Tier = "Expedited"
)

type TopicConfiguration struct {
	// 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.
	TopicArn *string
	// 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 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
	// 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.
	Events []Event
}

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
}

type TransitionStorageClass string

const (
	TransitionStorageClassGlacier             TransitionStorageClass = "GLACIER"
	TransitionStorageClassStandard_ia         TransitionStorageClass = "STANDARD_IA"
	TransitionStorageClassOnezone_ia          TransitionStorageClass = "ONEZONE_IA"
	TransitionStorageClassIntelligent_tiering TransitionStorageClass = "INTELLIGENT_TIERING"
	TransitionStorageClassDeep_archive        TransitionStorageClass = "DEEP_ARCHIVE"
)

type Type string

const (
	TypeCanonicaluser         Type = "CanonicalUser"
	TypeAmazoncustomerbyemail Type = "AmazonCustomerByEmail"
	TypeGroup                 Type = "Group"
)

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
}

type WebsiteConfiguration struct {
	// Rules that define when a redirect is applied and the redirect behavior.
	RoutingRules []*RoutingRule
	// 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
	// The name of the error document for the website.
	ErrorDocument *ErrorDocument
}