Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AbortIncompleteMultipartUpload

type AbortIncompleteMultipartUpload struct {

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

    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 AccelerateConfiguration

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

      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 AccessControlPolicy

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

        Contains the elements that set the ACL permissions for an object per grantee.

        type AccessControlTranslation

        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 container for information about access control for replicas.

          type AnalyticsAndOperator

          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
          }

            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 AnalyticsConfiguration

            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
            }

              Specifies the configuration and any analyses for the analytics filter of an Amazon S3 bucket.

              type AnalyticsExportDestination

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

                Where to publish the analytics results.

                type AnalyticsFilter

                type AnalyticsFilter interface {
                	// contains filtered or unexported methods
                }

                  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
                  
                  Example (OutputUsage)
                  Output:
                  
                  

                  type AnalyticsFilterMemberAnd

                  type AnalyticsFilterMemberAnd struct {
                  	Value AnalyticsAndOperator
                  }

                    A conjunction (logical AND) of predicates, which is used in evaluating an analytics filter. The operator must have at least two predicates.

                    type AnalyticsFilterMemberPrefix

                    type AnalyticsFilterMemberPrefix struct {
                    	Value string
                    }

                      The prefix to use when evaluating an analytics filter.

                      type AnalyticsFilterMemberTag

                      type AnalyticsFilterMemberTag struct {
                      	Value Tag
                      }

                        The tag to use when evaluating an analytics filter.

                        type AnalyticsS3BucketDestination

                        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
                        }

                          Contains information about where to publish the analytics results.

                          type AnalyticsS3ExportFileFormat

                          type AnalyticsS3ExportFileFormat string
                          const (
                          	AnalyticsS3ExportFileFormatCsv AnalyticsS3ExportFileFormat = "CSV"
                          )

                            Enum values for AnalyticsS3ExportFileFormat

                            func (AnalyticsS3ExportFileFormat) Values

                              Values returns all known values for AnalyticsS3ExportFileFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type ArchiveStatus

                              type ArchiveStatus string
                              const (
                              	ArchiveStatusArchiveAccess     ArchiveStatus = "ARCHIVE_ACCESS"
                              	ArchiveStatusDeepArchiveAccess ArchiveStatus = "DEEP_ARCHIVE_ACCESS"
                              )

                                Enum values for ArchiveStatus

                                func (ArchiveStatus) Values

                                func (ArchiveStatus) Values() []ArchiveStatus

                                  Values returns all known values for ArchiveStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type Bucket

                                  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
                                  }

                                    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 BucketAccelerateStatus

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

                                      Enum values for BucketAccelerateStatus

                                      func (BucketAccelerateStatus) Values

                                        Values returns all known values for BucketAccelerateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                        type BucketAlreadyExists

                                        type BucketAlreadyExists struct {
                                        	Message *string
                                        }

                                          The requested bucket name is not available. The bucket namespace is shared by all users of the system. Select a different name and try again.

                                          func (*BucketAlreadyExists) Error

                                          func (e *BucketAlreadyExists) Error() string

                                          func (*BucketAlreadyExists) ErrorCode

                                          func (e *BucketAlreadyExists) ErrorCode() string

                                          func (*BucketAlreadyExists) ErrorFault

                                          func (e *BucketAlreadyExists) ErrorFault() smithy.ErrorFault

                                          func (*BucketAlreadyExists) ErrorMessage

                                          func (e *BucketAlreadyExists) ErrorMessage() string

                                          type BucketAlreadyOwnedByYou

                                          type BucketAlreadyOwnedByYou struct {
                                          	Message *string
                                          }

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

                                            func (*BucketAlreadyOwnedByYou) Error

                                            func (e *BucketAlreadyOwnedByYou) Error() string

                                            func (*BucketAlreadyOwnedByYou) ErrorCode

                                            func (e *BucketAlreadyOwnedByYou) ErrorCode() string

                                            func (*BucketAlreadyOwnedByYou) ErrorFault

                                            func (e *BucketAlreadyOwnedByYou) ErrorFault() smithy.ErrorFault

                                            func (*BucketAlreadyOwnedByYou) ErrorMessage

                                            func (e *BucketAlreadyOwnedByYou) ErrorMessage() string

                                            type BucketCannedACL

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

                                              Enum values for BucketCannedACL

                                              func (BucketCannedACL) Values

                                              func (BucketCannedACL) Values() []BucketCannedACL

                                                Values returns all known values for BucketCannedACL. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                type BucketLifecycleConfiguration

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

                                                  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 BucketLocationConstraint

                                                  type BucketLocationConstraint string
                                                  const (
                                                  	BucketLocationConstraintAfSouth1     BucketLocationConstraint = "af-south-1"
                                                  	BucketLocationConstraintApEast1      BucketLocationConstraint = "ap-east-1"
                                                  	BucketLocationConstraintApNortheast1 BucketLocationConstraint = "ap-northeast-1"
                                                  	BucketLocationConstraintApNortheast2 BucketLocationConstraint = "ap-northeast-2"
                                                  	BucketLocationConstraintApNortheast3 BucketLocationConstraint = "ap-northeast-3"
                                                  	BucketLocationConstraintApSouth1     BucketLocationConstraint = "ap-south-1"
                                                  	BucketLocationConstraintApSoutheast1 BucketLocationConstraint = "ap-southeast-1"
                                                  	BucketLocationConstraintApSoutheast2 BucketLocationConstraint = "ap-southeast-2"
                                                  	BucketLocationConstraintCaCentral1   BucketLocationConstraint = "ca-central-1"
                                                  	BucketLocationConstraintCnNorth1     BucketLocationConstraint = "cn-north-1"
                                                  	BucketLocationConstraintCnNorthwest1 BucketLocationConstraint = "cn-northwest-1"
                                                  	BucketLocationConstraintEu           BucketLocationConstraint = "EU"
                                                  	BucketLocationConstraintEuCentral1   BucketLocationConstraint = "eu-central-1"
                                                  	BucketLocationConstraintEuNorth1     BucketLocationConstraint = "eu-north-1"
                                                  	BucketLocationConstraintEuSouth1     BucketLocationConstraint = "eu-south-1"
                                                  	BucketLocationConstraintEuWest1      BucketLocationConstraint = "eu-west-1"
                                                  	BucketLocationConstraintEuWest2      BucketLocationConstraint = "eu-west-2"
                                                  	BucketLocationConstraintEuWest3      BucketLocationConstraint = "eu-west-3"
                                                  	BucketLocationConstraintMeSouth1     BucketLocationConstraint = "me-south-1"
                                                  	BucketLocationConstraintSaEast1      BucketLocationConstraint = "sa-east-1"
                                                  	BucketLocationConstraintUsEast2      BucketLocationConstraint = "us-east-2"
                                                  	BucketLocationConstraintUsGovEast1   BucketLocationConstraint = "us-gov-east-1"
                                                  	BucketLocationConstraintUsGovWest1   BucketLocationConstraint = "us-gov-west-1"
                                                  	BucketLocationConstraintUsWest1      BucketLocationConstraint = "us-west-1"
                                                  	BucketLocationConstraintUsWest2      BucketLocationConstraint = "us-west-2"
                                                  )

                                                    Enum values for BucketLocationConstraint

                                                    func (BucketLocationConstraint) Values

                                                      Values returns all known values for BucketLocationConstraint. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                      type BucketLoggingStatus

                                                      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 logging status information.

                                                        type BucketLogsPermission

                                                        type BucketLogsPermission string
                                                        const (
                                                        	BucketLogsPermissionFullControl BucketLogsPermission = "FULL_CONTROL"
                                                        	BucketLogsPermissionRead        BucketLogsPermission = "READ"
                                                        	BucketLogsPermissionWrite       BucketLogsPermission = "WRITE"
                                                        )

                                                          Enum values for BucketLogsPermission

                                                          func (BucketLogsPermission) Values

                                                            Values returns all known values for BucketLogsPermission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                            type BucketVersioningStatus

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

                                                              Enum values for BucketVersioningStatus

                                                              func (BucketVersioningStatus) Values

                                                                Values returns all known values for BucketVersioningStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                type CORSConfiguration

                                                                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
                                                                }

                                                                  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 CORSRule

                                                                  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
                                                                  }

                                                                    Specifies a cross-origin access rule for an Amazon S3 bucket.

                                                                    type CSVInput

                                                                    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 an uncompressed comma-separated values (CSV)-formatted input object is formatted.

                                                                      type CSVOutput

                                                                      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
                                                                      }

                                                                        Describes how uncompressed comma-separated values (CSV)-formatted results are formatted.

                                                                        type CommonPrefix

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

                                                                          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 CompletedMultipartUpload

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

                                                                            The container for the completed multipart upload details.

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

                                                                              Details of the parts that were uploaded.

                                                                              type CompressionType

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

                                                                                Enum values for CompressionType

                                                                                func (CompressionType) Values

                                                                                func (CompressionType) Values() []CompressionType

                                                                                  Values returns all known values for CompressionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                  type Condition

                                                                                  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
                                                                                  }

                                                                                    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 CopyObjectResult

                                                                                    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

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

                                                                                        Container for all response elements.

                                                                                        type CreateBucketConfiguration

                                                                                        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
                                                                                        }

                                                                                          The configuration information for the bucket.

                                                                                          type DefaultRetention

                                                                                          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
                                                                                          }

                                                                                            The container element for specifying the default Object Lock retention settings for new objects placed in the specified bucket.

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

                                                                                              Container for the objects to delete.

                                                                                              type DeleteMarkerEntry

                                                                                              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
                                                                                              }

                                                                                                Information about the delete marker.

                                                                                                type DeleteMarkerReplication

                                                                                                type DeleteMarkerReplication struct {
                                                                                                
                                                                                                	// Indicates whether to replicate delete markers. Indicates whether to replicate
                                                                                                	// delete markers.
                                                                                                	Status DeleteMarkerReplicationStatus
                                                                                                }

                                                                                                  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 DeleteMarkerReplicationStatus

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

                                                                                                    Enum values for DeleteMarkerReplicationStatus

                                                                                                    func (DeleteMarkerReplicationStatus) Values

                                                                                                      Values returns all known values for DeleteMarkerReplicationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                      type DeletedObject

                                                                                                      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 deleted object.

                                                                                                        type Destination

                                                                                                        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
                                                                                                        }

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

                                                                                                          type EncodingType

                                                                                                          type EncodingType string
                                                                                                          const (
                                                                                                          	EncodingTypeUrl EncodingType = "url"
                                                                                                          )

                                                                                                            Enum values for EncodingType

                                                                                                            func (EncodingType) Values

                                                                                                            func (EncodingType) Values() []EncodingType

                                                                                                              Values returns all known values for EncodingType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                              type Encryption

                                                                                                              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
                                                                                                              }

                                                                                                                Contains the type of server-side encryption used.

                                                                                                                type EncryptionConfiguration

                                                                                                                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
                                                                                                                }

                                                                                                                  Specifies encryption-related information for an Amazon S3 bucket that is a destination for replicated objects.

                                                                                                                  type Error

                                                                                                                  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
                                                                                                                  }

                                                                                                                    Container for all error elements.

                                                                                                                    type ErrorDocument

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

                                                                                                                      The error information.

                                                                                                                      type Event

                                                                                                                      type Event string

                                                                                                                      func (Event) Values

                                                                                                                      func (Event) Values() []Event

                                                                                                                        Values returns all known values for Event. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                        type ExistingObjectReplication

                                                                                                                        type ExistingObjectReplication struct {
                                                                                                                        
                                                                                                                        	//
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	Status ExistingObjectReplicationStatus
                                                                                                                        }

                                                                                                                          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 ExistingObjectReplicationStatus

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

                                                                                                                            Enum values for ExistingObjectReplicationStatus

                                                                                                                            func (ExistingObjectReplicationStatus) Values

                                                                                                                              Values returns all known values for ExistingObjectReplicationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                              type ExpirationStatus

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

                                                                                                                                Enum values for ExpirationStatus

                                                                                                                                func (ExpirationStatus) Values

                                                                                                                                  Values returns all known values for ExpirationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type ExpressionType

                                                                                                                                  type ExpressionType string
                                                                                                                                  const (
                                                                                                                                  	ExpressionTypeSql ExpressionType = "SQL"
                                                                                                                                  )

                                                                                                                                    Enum values for ExpressionType

                                                                                                                                    func (ExpressionType) Values

                                                                                                                                    func (ExpressionType) Values() []ExpressionType

                                                                                                                                      Values returns all known values for ExpressionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                      type FileHeaderInfo

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

                                                                                                                                        Enum values for FileHeaderInfo

                                                                                                                                        func (FileHeaderInfo) Values

                                                                                                                                        func (FileHeaderInfo) Values() []FileHeaderInfo

                                                                                                                                          Values returns all known values for FileHeaderInfo. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                          type FilterRule

                                                                                                                                          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
                                                                                                                                          }

                                                                                                                                            Specifies the Amazon S3 object key name to filter on and whether to filter on the suffix or prefix of the key name.

                                                                                                                                            type FilterRuleName

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

                                                                                                                                              Enum values for FilterRuleName

                                                                                                                                              func (FilterRuleName) Values

                                                                                                                                              func (FilterRuleName) Values() []FilterRuleName

                                                                                                                                                Values returns all known values for FilterRuleName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type GlacierJobParameters

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

                                                                                                                                                  Container for S3 Glacier job parameters.

                                                                                                                                                  type Grant

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

                                                                                                                                                    Container for grant information.

                                                                                                                                                    type Grantee

                                                                                                                                                    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 person being granted permissions.

                                                                                                                                                      type IndexDocument

                                                                                                                                                      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 for the Suffix element.

                                                                                                                                                        type Initiator

                                                                                                                                                        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
                                                                                                                                                        }

                                                                                                                                                          Container element that identifies who initiated the multipart upload.

                                                                                                                                                          type InputSerialization

                                                                                                                                                          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
                                                                                                                                                          }

                                                                                                                                                            Describes the serialization format of the object.

                                                                                                                                                            type IntelligentTieringAccessTier

                                                                                                                                                            type IntelligentTieringAccessTier string
                                                                                                                                                            const (
                                                                                                                                                            	IntelligentTieringAccessTierArchiveAccess     IntelligentTieringAccessTier = "ARCHIVE_ACCESS"
                                                                                                                                                            	IntelligentTieringAccessTierDeepArchiveAccess IntelligentTieringAccessTier = "DEEP_ARCHIVE_ACCESS"
                                                                                                                                                            )

                                                                                                                                                              Enum values for IntelligentTieringAccessTier

                                                                                                                                                              func (IntelligentTieringAccessTier) Values

                                                                                                                                                                Values returns all known values for IntelligentTieringAccessTier. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                type IntelligentTieringAndOperator

                                                                                                                                                                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
                                                                                                                                                                }

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

                                                                                                                                                                  type IntelligentTieringConfiguration

                                                                                                                                                                  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
                                                                                                                                                                  }

                                                                                                                                                                    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 IntelligentTieringFilter

                                                                                                                                                                    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
                                                                                                                                                                    }

                                                                                                                                                                      The Filter is used to identify objects that the S3 Intelligent-Tiering configuration applies to.

                                                                                                                                                                      type IntelligentTieringStatus

                                                                                                                                                                      type IntelligentTieringStatus string
                                                                                                                                                                      const (
                                                                                                                                                                      	IntelligentTieringStatusEnabled  IntelligentTieringStatus = "Enabled"
                                                                                                                                                                      	IntelligentTieringStatusDisabled IntelligentTieringStatus = "Disabled"
                                                                                                                                                                      )

                                                                                                                                                                        Enum values for IntelligentTieringStatus

                                                                                                                                                                        func (IntelligentTieringStatus) Values

                                                                                                                                                                          Values returns all known values for IntelligentTieringStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                          type InvalidObjectState

                                                                                                                                                                          type InvalidObjectState struct {
                                                                                                                                                                          	Message *string
                                                                                                                                                                          
                                                                                                                                                                          	StorageClass StorageClass
                                                                                                                                                                          	AccessTier   IntelligentTieringAccessTier
                                                                                                                                                                          }

                                                                                                                                                                            Object is archived and inaccessible until restored.

                                                                                                                                                                            func (*InvalidObjectState) Error

                                                                                                                                                                            func (e *InvalidObjectState) Error() string

                                                                                                                                                                            func (*InvalidObjectState) ErrorCode

                                                                                                                                                                            func (e *InvalidObjectState) ErrorCode() string

                                                                                                                                                                            func (*InvalidObjectState) ErrorFault

                                                                                                                                                                            func (e *InvalidObjectState) ErrorFault() smithy.ErrorFault

                                                                                                                                                                            func (*InvalidObjectState) ErrorMessage

                                                                                                                                                                            func (e *InvalidObjectState) ErrorMessage() string

                                                                                                                                                                            type InventoryConfiguration

                                                                                                                                                                            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. 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 InventoryDestination

                                                                                                                                                                              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
                                                                                                                                                                              }

                                                                                                                                                                                Specifies the inventory configuration for an Amazon S3 bucket.

                                                                                                                                                                                type InventoryEncryption

                                                                                                                                                                                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
                                                                                                                                                                                }

                                                                                                                                                                                  Contains the type of server-side encryption used to encrypt the inventory results.

                                                                                                                                                                                  type InventoryFilter

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

                                                                                                                                                                                    Specifies an inventory filter. The inventory only includes objects that meet the filter's criteria.

                                                                                                                                                                                    type InventoryFormat

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

                                                                                                                                                                                      Enum values for InventoryFormat

                                                                                                                                                                                      func (InventoryFormat) Values

                                                                                                                                                                                      func (InventoryFormat) Values() []InventoryFormat

                                                                                                                                                                                        Values returns all known values for InventoryFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                        type InventoryFrequency

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

                                                                                                                                                                                          Enum values for InventoryFrequency

                                                                                                                                                                                          func (InventoryFrequency) Values

                                                                                                                                                                                            Values returns all known values for InventoryFrequency. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                            type InventoryIncludedObjectVersions

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

                                                                                                                                                                                              Enum values for InventoryIncludedObjectVersions

                                                                                                                                                                                              func (InventoryIncludedObjectVersions) Values

                                                                                                                                                                                                Values returns all known values for InventoryIncludedObjectVersions. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                type InventoryOptionalField

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

                                                                                                                                                                                                  Enum values for InventoryOptionalField

                                                                                                                                                                                                  func (InventoryOptionalField) Values

                                                                                                                                                                                                    Values returns all known values for InventoryOptionalField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                    type InventoryS3BucketDestination

                                                                                                                                                                                                    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
                                                                                                                                                                                                    }

                                                                                                                                                                                                      Contains the bucket name, file format, bucket owner (optional), and prefix (optional) where inventory results are published.

                                                                                                                                                                                                      type InventorySchedule

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

                                                                                                                                                                                                        Specifies the schedule for generating inventory results.

                                                                                                                                                                                                        type JSONInput

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

                                                                                                                                                                                                          Specifies JSON as object's input serialization format.

                                                                                                                                                                                                          type JSONOutput

                                                                                                                                                                                                          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
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Specifies JSON as request's output serialization format.

                                                                                                                                                                                                            type JSONType

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

                                                                                                                                                                                                              Enum values for JSONType

                                                                                                                                                                                                              func (JSONType) Values

                                                                                                                                                                                                              func (JSONType) Values() []JSONType

                                                                                                                                                                                                                Values returns all known values for JSONType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                type LambdaFunctionConfiguration

                                                                                                                                                                                                                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
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  A container for specifying the configuration for AWS Lambda notifications.

                                                                                                                                                                                                                  type LifecycleExpiration

                                                                                                                                                                                                                  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
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    Container for the expiration for the lifecycle of the object.

                                                                                                                                                                                                                    type LifecycleRule

                                                                                                                                                                                                                    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
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      A lifecycle rule for individual objects in an Amazon S3 bucket.

                                                                                                                                                                                                                      type LifecycleRuleAndOperator

                                                                                                                                                                                                                      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
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        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 LifecycleRuleFilter

                                                                                                                                                                                                                        type LifecycleRuleFilter interface {
                                                                                                                                                                                                                        	// contains filtered or unexported methods
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          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
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          Example (OutputUsage)
                                                                                                                                                                                                                          Output:
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          

                                                                                                                                                                                                                          type LifecycleRuleFilterMemberAnd

                                                                                                                                                                                                                          type LifecycleRuleFilterMemberAnd struct {
                                                                                                                                                                                                                          	Value LifecycleRuleAndOperator
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            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 LifecycleRuleFilterMemberPrefix

                                                                                                                                                                                                                            type LifecycleRuleFilterMemberPrefix struct {
                                                                                                                                                                                                                            	Value string
                                                                                                                                                                                                                            }

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

                                                                                                                                                                                                                              type LifecycleRuleFilterMemberTag

                                                                                                                                                                                                                              type LifecycleRuleFilterMemberTag struct {
                                                                                                                                                                                                                              	Value Tag
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                This tag must exist in the object's tag set in order for the rule to apply.

                                                                                                                                                                                                                                type LoggingEnabled

                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  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 MFADelete

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

                                                                                                                                                                                                                                    Enum values for MFADelete

                                                                                                                                                                                                                                    func (MFADelete) Values

                                                                                                                                                                                                                                    func (MFADelete) Values() []MFADelete

                                                                                                                                                                                                                                      Values returns all known values for MFADelete. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                      type MFADeleteStatus

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

                                                                                                                                                                                                                                        Enum values for MFADeleteStatus

                                                                                                                                                                                                                                        func (MFADeleteStatus) Values

                                                                                                                                                                                                                                        func (MFADeleteStatus) Values() []MFADeleteStatus

                                                                                                                                                                                                                                          Values returns all known values for MFADeleteStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                          type MetadataDirective

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

                                                                                                                                                                                                                                            Enum values for MetadataDirective

                                                                                                                                                                                                                                            func (MetadataDirective) Values

                                                                                                                                                                                                                                              Values returns all known values for MetadataDirective. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                              type MetadataEntry

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

                                                                                                                                                                                                                                                A metadata key-value pair to store with an object.

                                                                                                                                                                                                                                                type Metrics

                                                                                                                                                                                                                                                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 container specifying replication metrics-related settings enabling replication metrics and events.

                                                                                                                                                                                                                                                  type MetricsAndOperator

                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    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 MetricsConfiguration

                                                                                                                                                                                                                                                    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 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 MetricsFilter

                                                                                                                                                                                                                                                      type MetricsFilter interface {
                                                                                                                                                                                                                                                      	// contains filtered or unexported methods
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        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
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        Example (OutputUsage)
                                                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                        type MetricsFilterMemberAnd

                                                                                                                                                                                                                                                        type MetricsFilterMemberAnd struct {
                                                                                                                                                                                                                                                        	Value MetricsAndOperator
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          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 MetricsFilterMemberPrefix

                                                                                                                                                                                                                                                          type MetricsFilterMemberPrefix struct {
                                                                                                                                                                                                                                                          	Value string
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            The prefix used when evaluating a metrics filter.

                                                                                                                                                                                                                                                            type MetricsFilterMemberTag

                                                                                                                                                                                                                                                            type MetricsFilterMemberTag struct {
                                                                                                                                                                                                                                                            	Value Tag
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              The tag used when evaluating a metrics filter.

                                                                                                                                                                                                                                                              type MetricsStatus

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

                                                                                                                                                                                                                                                                Enum values for MetricsStatus

                                                                                                                                                                                                                                                                func (MetricsStatus) Values

                                                                                                                                                                                                                                                                func (MetricsStatus) Values() []MetricsStatus

                                                                                                                                                                                                                                                                  Values returns all known values for MetricsStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                  type MultipartUpload

                                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    Container for the MultipartUpload for the Amazon S3 object.

                                                                                                                                                                                                                                                                    type NoSuchBucket

                                                                                                                                                                                                                                                                    type NoSuchBucket struct {
                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      The specified bucket does not exist.

                                                                                                                                                                                                                                                                      func (*NoSuchBucket) Error

                                                                                                                                                                                                                                                                      func (e *NoSuchBucket) Error() string

                                                                                                                                                                                                                                                                      func (*NoSuchBucket) ErrorCode

                                                                                                                                                                                                                                                                      func (e *NoSuchBucket) ErrorCode() string

                                                                                                                                                                                                                                                                      func (*NoSuchBucket) ErrorFault

                                                                                                                                                                                                                                                                      func (e *NoSuchBucket) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                      func (*NoSuchBucket) ErrorMessage

                                                                                                                                                                                                                                                                      func (e *NoSuchBucket) ErrorMessage() string

                                                                                                                                                                                                                                                                      type NoSuchKey

                                                                                                                                                                                                                                                                      type NoSuchKey struct {
                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        The specified key does not exist.

                                                                                                                                                                                                                                                                        func (*NoSuchKey) Error

                                                                                                                                                                                                                                                                        func (e *NoSuchKey) Error() string

                                                                                                                                                                                                                                                                        func (*NoSuchKey) ErrorCode

                                                                                                                                                                                                                                                                        func (e *NoSuchKey) ErrorCode() string

                                                                                                                                                                                                                                                                        func (*NoSuchKey) ErrorFault

                                                                                                                                                                                                                                                                        func (e *NoSuchKey) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                        func (*NoSuchKey) ErrorMessage

                                                                                                                                                                                                                                                                        func (e *NoSuchKey) ErrorMessage() string

                                                                                                                                                                                                                                                                        type NoSuchUpload

                                                                                                                                                                                                                                                                        type NoSuchUpload struct {
                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          The specified multipart upload does not exist.

                                                                                                                                                                                                                                                                          func (*NoSuchUpload) Error

                                                                                                                                                                                                                                                                          func (e *NoSuchUpload) Error() string

                                                                                                                                                                                                                                                                          func (*NoSuchUpload) ErrorCode

                                                                                                                                                                                                                                                                          func (e *NoSuchUpload) ErrorCode() string

                                                                                                                                                                                                                                                                          func (*NoSuchUpload) ErrorFault

                                                                                                                                                                                                                                                                          func (e *NoSuchUpload) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                          func (*NoSuchUpload) ErrorMessage

                                                                                                                                                                                                                                                                          func (e *NoSuchUpload) ErrorMessage() string

                                                                                                                                                                                                                                                                          type NoncurrentVersionExpiration

                                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            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 NoncurrentVersionTransition

                                                                                                                                                                                                                                                                            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
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              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 NotFound

                                                                                                                                                                                                                                                                              type NotFound struct {
                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                The specified content does not exist.

                                                                                                                                                                                                                                                                                func (*NotFound) Error

                                                                                                                                                                                                                                                                                func (e *NotFound) Error() string

                                                                                                                                                                                                                                                                                func (*NotFound) ErrorCode

                                                                                                                                                                                                                                                                                func (e *NotFound) ErrorCode() string

                                                                                                                                                                                                                                                                                func (*NotFound) ErrorFault

                                                                                                                                                                                                                                                                                func (e *NotFound) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                func (*NotFound) ErrorMessage

                                                                                                                                                                                                                                                                                func (e *NotFound) ErrorMessage() string

                                                                                                                                                                                                                                                                                type NotificationConfiguration

                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                }

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

                                                                                                                                                                                                                                                                                  type NotificationConfigurationFilter

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

                                                                                                                                                                                                                                                                                    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 Object

                                                                                                                                                                                                                                                                                    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
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      An object consists of data and its descriptive metadata.

                                                                                                                                                                                                                                                                                      type ObjectAlreadyInActiveTierError

                                                                                                                                                                                                                                                                                      type ObjectAlreadyInActiveTierError struct {
                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        This operation is not allowed against this storage tier.

                                                                                                                                                                                                                                                                                        func (*ObjectAlreadyInActiveTierError) Error

                                                                                                                                                                                                                                                                                        func (*ObjectAlreadyInActiveTierError) ErrorCode

                                                                                                                                                                                                                                                                                        func (e *ObjectAlreadyInActiveTierError) ErrorCode() string

                                                                                                                                                                                                                                                                                        func (*ObjectAlreadyInActiveTierError) ErrorFault

                                                                                                                                                                                                                                                                                        func (*ObjectAlreadyInActiveTierError) ErrorMessage

                                                                                                                                                                                                                                                                                        func (e *ObjectAlreadyInActiveTierError) ErrorMessage() string

                                                                                                                                                                                                                                                                                        type ObjectCannedACL

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

                                                                                                                                                                                                                                                                                          Enum values for ObjectCannedACL

                                                                                                                                                                                                                                                                                          func (ObjectCannedACL) Values

                                                                                                                                                                                                                                                                                          func (ObjectCannedACL) Values() []ObjectCannedACL

                                                                                                                                                                                                                                                                                            Values returns all known values for ObjectCannedACL. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                            type ObjectIdentifier

                                                                                                                                                                                                                                                                                            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
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              Object Identifier is unique value to identify objects.

                                                                                                                                                                                                                                                                                              type ObjectLockConfiguration

                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                The container element for Object Lock configuration parameters.

                                                                                                                                                                                                                                                                                                type ObjectLockEnabled

                                                                                                                                                                                                                                                                                                type ObjectLockEnabled string
                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                	ObjectLockEnabledEnabled ObjectLockEnabled = "Enabled"
                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                  Enum values for ObjectLockEnabled

                                                                                                                                                                                                                                                                                                  func (ObjectLockEnabled) Values

                                                                                                                                                                                                                                                                                                    Values returns all known values for ObjectLockEnabled. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                    type ObjectLockLegalHold

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

                                                                                                                                                                                                                                                                                                      A Legal Hold configuration for an object.

                                                                                                                                                                                                                                                                                                      type ObjectLockLegalHoldStatus

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

                                                                                                                                                                                                                                                                                                        Enum values for ObjectLockLegalHoldStatus

                                                                                                                                                                                                                                                                                                        func (ObjectLockLegalHoldStatus) Values

                                                                                                                                                                                                                                                                                                          Values returns all known values for ObjectLockLegalHoldStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                          type ObjectLockMode

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

                                                                                                                                                                                                                                                                                                            Enum values for ObjectLockMode

                                                                                                                                                                                                                                                                                                            func (ObjectLockMode) Values

                                                                                                                                                                                                                                                                                                            func (ObjectLockMode) Values() []ObjectLockMode

                                                                                                                                                                                                                                                                                                              Values returns all known values for ObjectLockMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                              type ObjectLockRetention

                                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                A Retention configuration for an object.

                                                                                                                                                                                                                                                                                                                type ObjectLockRetentionMode

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

                                                                                                                                                                                                                                                                                                                  Enum values for ObjectLockRetentionMode

                                                                                                                                                                                                                                                                                                                  func (ObjectLockRetentionMode) Values

                                                                                                                                                                                                                                                                                                                    Values returns all known values for ObjectLockRetentionMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                    type ObjectLockRule

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

                                                                                                                                                                                                                                                                                                                      The container element for an Object Lock rule.

                                                                                                                                                                                                                                                                                                                      type ObjectNotInActiveTierError

                                                                                                                                                                                                                                                                                                                      type ObjectNotInActiveTierError struct {
                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        The source object of the COPY operation is not in the active tier and is only stored in Amazon S3 Glacier.

                                                                                                                                                                                                                                                                                                                        func (*ObjectNotInActiveTierError) Error

                                                                                                                                                                                                                                                                                                                        func (*ObjectNotInActiveTierError) ErrorCode

                                                                                                                                                                                                                                                                                                                        func (e *ObjectNotInActiveTierError) ErrorCode() string

                                                                                                                                                                                                                                                                                                                        func (*ObjectNotInActiveTierError) ErrorFault

                                                                                                                                                                                                                                                                                                                        func (*ObjectNotInActiveTierError) ErrorMessage

                                                                                                                                                                                                                                                                                                                        func (e *ObjectNotInActiveTierError) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                        type ObjectOwnership

                                                                                                                                                                                                                                                                                                                        type ObjectOwnership string
                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                        	ObjectOwnershipBucketOwnerPreferred ObjectOwnership = "BucketOwnerPreferred"
                                                                                                                                                                                                                                                                                                                        	ObjectOwnershipObjectWriter         ObjectOwnership = "ObjectWriter"
                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                          Enum values for ObjectOwnership

                                                                                                                                                                                                                                                                                                                          func (ObjectOwnership) Values

                                                                                                                                                                                                                                                                                                                          func (ObjectOwnership) Values() []ObjectOwnership

                                                                                                                                                                                                                                                                                                                            Values returns all known values for ObjectOwnership. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                            type ObjectStorageClass

                                                                                                                                                                                                                                                                                                                            type ObjectStorageClass string
                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassStandard           ObjectStorageClass = "STANDARD"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassReducedRedundancy  ObjectStorageClass = "REDUCED_REDUNDANCY"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassGlacier            ObjectStorageClass = "GLACIER"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassStandardIa         ObjectStorageClass = "STANDARD_IA"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassOnezoneIa          ObjectStorageClass = "ONEZONE_IA"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassIntelligentTiering ObjectStorageClass = "INTELLIGENT_TIERING"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassDeepArchive        ObjectStorageClass = "DEEP_ARCHIVE"
                                                                                                                                                                                                                                                                                                                            	ObjectStorageClassOutposts           ObjectStorageClass = "OUTPOSTS"
                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                              Enum values for ObjectStorageClass

                                                                                                                                                                                                                                                                                                                              func (ObjectStorageClass) Values

                                                                                                                                                                                                                                                                                                                                Values returns all known values for ObjectStorageClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                type ObjectVersion

                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  The version of an object.

                                                                                                                                                                                                                                                                                                                                  type ObjectVersionStorageClass

                                                                                                                                                                                                                                                                                                                                  type ObjectVersionStorageClass string
                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                  	ObjectVersionStorageClassStandard ObjectVersionStorageClass = "STANDARD"
                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                    Enum values for ObjectVersionStorageClass

                                                                                                                                                                                                                                                                                                                                    func (ObjectVersionStorageClass) Values

                                                                                                                                                                                                                                                                                                                                      Values returns all known values for ObjectVersionStorageClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                      type OutputLocation

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

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

                                                                                                                                                                                                                                                                                                                                        type OutputSerialization

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

                                                                                                                                                                                                                                                                                                                                          Describes how results of the Select job are serialized.

                                                                                                                                                                                                                                                                                                                                          type Owner

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

                                                                                                                                                                                                                                                                                                                                            Container for the owner's display name and ID.

                                                                                                                                                                                                                                                                                                                                            type OwnerOverride

                                                                                                                                                                                                                                                                                                                                            type OwnerOverride string
                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                            	OwnerOverrideDestination OwnerOverride = "Destination"
                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                              Enum values for OwnerOverride

                                                                                                                                                                                                                                                                                                                                              func (OwnerOverride) Values

                                                                                                                                                                                                                                                                                                                                              func (OwnerOverride) Values() []OwnerOverride

                                                                                                                                                                                                                                                                                                                                                Values returns all known values for OwnerOverride. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                type OwnershipControls

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

                                                                                                                                                                                                                                                                                                                                                  The container element for a bucket's ownership controls.

                                                                                                                                                                                                                                                                                                                                                  type OwnershipControlsRule

                                                                                                                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    The container element for an ownership control rule.

                                                                                                                                                                                                                                                                                                                                                    type ParquetInput

                                                                                                                                                                                                                                                                                                                                                    type ParquetInput struct {
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      Container for Parquet.

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

                                                                                                                                                                                                                                                                                                                                                        Container for elements related to a part.

                                                                                                                                                                                                                                                                                                                                                        type Payer

                                                                                                                                                                                                                                                                                                                                                        type Payer string
                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                        	PayerRequester   Payer = "Requester"
                                                                                                                                                                                                                                                                                                                                                        	PayerBucketOwner Payer = "BucketOwner"
                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                          Enum values for Payer

                                                                                                                                                                                                                                                                                                                                                          func (Payer) Values

                                                                                                                                                                                                                                                                                                                                                          func (Payer) Values() []Payer

                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for Payer. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                            type Permission

                                                                                                                                                                                                                                                                                                                                                            type Permission string
                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                            	PermissionFullControl Permission = "FULL_CONTROL"
                                                                                                                                                                                                                                                                                                                                                            	PermissionWrite       Permission = "WRITE"
                                                                                                                                                                                                                                                                                                                                                            	PermissionWriteAcp    Permission = "WRITE_ACP"
                                                                                                                                                                                                                                                                                                                                                            	PermissionRead        Permission = "READ"
                                                                                                                                                                                                                                                                                                                                                            	PermissionReadAcp     Permission = "READ_ACP"
                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                              Enum values for Permission

                                                                                                                                                                                                                                                                                                                                                              func (Permission) Values

                                                                                                                                                                                                                                                                                                                                                              func (Permission) Values() []Permission

                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for Permission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                type PolicyStatus

                                                                                                                                                                                                                                                                                                                                                                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 container element for a bucket's policy status.

                                                                                                                                                                                                                                                                                                                                                                  type Protocol

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

                                                                                                                                                                                                                                                                                                                                                                    Enum values for Protocol

                                                                                                                                                                                                                                                                                                                                                                    func (Protocol) Values

                                                                                                                                                                                                                                                                                                                                                                    func (Protocol) Values() []Protocol

                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for Protocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                      type PublicAccessBlockConfiguration

                                                                                                                                                                                                                                                                                                                                                                      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
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        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 QueueConfiguration

                                                                                                                                                                                                                                                                                                                                                                        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 the configuration for publishing messages to an Amazon Simple Queue Service (Amazon SQS) queue when Amazon S3 detects specified events.

                                                                                                                                                                                                                                                                                                                                                                          type QuoteFields

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

                                                                                                                                                                                                                                                                                                                                                                            Enum values for QuoteFields

                                                                                                                                                                                                                                                                                                                                                                            func (QuoteFields) Values

                                                                                                                                                                                                                                                                                                                                                                            func (QuoteFields) Values() []QuoteFields

                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for QuoteFields. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                              type Redirect

                                                                                                                                                                                                                                                                                                                                                                              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 how requests are redirected. In the event of an error, you can specify a different error code to return.

                                                                                                                                                                                                                                                                                                                                                                                type RedirectAllRequestsTo

                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  Specifies the redirect behavior of all requests to a website endpoint of an Amazon S3 bucket.

                                                                                                                                                                                                                                                                                                                                                                                  type ReplicaModifications

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

                                                                                                                                                                                                                                                                                                                                                                                    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 ReplicaModificationsStatus

                                                                                                                                                                                                                                                                                                                                                                                    type ReplicaModificationsStatus string
                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                    	ReplicaModificationsStatusEnabled  ReplicaModificationsStatus = "Enabled"
                                                                                                                                                                                                                                                                                                                                                                                    	ReplicaModificationsStatusDisabled ReplicaModificationsStatus = "Disabled"
                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                      Enum values for ReplicaModificationsStatus

                                                                                                                                                                                                                                                                                                                                                                                      func (ReplicaModificationsStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for ReplicaModificationsStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                        type ReplicationConfiguration

                                                                                                                                                                                                                                                                                                                                                                                        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
                                                                                                                                                                                                                                                                                                                                                                                        }

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

                                                                                                                                                                                                                                                                                                                                                                                          type ReplicationRule

                                                                                                                                                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            Specifies which Amazon S3 objects to replicate and where to store the replicas.

                                                                                                                                                                                                                                                                                                                                                                                            type ReplicationRuleAndOperator

                                                                                                                                                                                                                                                                                                                                                                                            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 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 ReplicationRuleFilter

                                                                                                                                                                                                                                                                                                                                                                                              type ReplicationRuleFilter interface {
                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                Example (OutputUsage)
                                                                                                                                                                                                                                                                                                                                                                                                Output:
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                type ReplicationRuleFilterMemberAnd

                                                                                                                                                                                                                                                                                                                                                                                                type ReplicationRuleFilterMemberAnd struct {
                                                                                                                                                                                                                                                                                                                                                                                                	Value ReplicationRuleAndOperator
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  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 ReplicationRuleFilterMemberPrefix

                                                                                                                                                                                                                                                                                                                                                                                                  type ReplicationRuleFilterMemberPrefix struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Value string
                                                                                                                                                                                                                                                                                                                                                                                                  }

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

                                                                                                                                                                                                                                                                                                                                                                                                    type ReplicationRuleFilterMemberTag

                                                                                                                                                                                                                                                                                                                                                                                                    type ReplicationRuleFilterMemberTag struct {
                                                                                                                                                                                                                                                                                                                                                                                                    	Value Tag
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      A container for specifying a tag key and value. The rule applies only to objects that have the tag in their tag set.

                                                                                                                                                                                                                                                                                                                                                                                                      type ReplicationRuleStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for ReplicationRuleStatus

                                                                                                                                                                                                                                                                                                                                                                                                        func (ReplicationRuleStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for ReplicationRuleStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                          type ReplicationStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for ReplicationStatus

                                                                                                                                                                                                                                                                                                                                                                                                            func (ReplicationStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for ReplicationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                              type ReplicationTime

                                                                                                                                                                                                                                                                                                                                                                                                              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 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 ReplicationTimeStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for ReplicationTimeStatus

                                                                                                                                                                                                                                                                                                                                                                                                                  func (ReplicationTimeStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for ReplicationTimeStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                    type ReplicationTimeValue

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

                                                                                                                                                                                                                                                                                                                                                                                                                      A container specifying the time value for S3 Replication Time Control (S3 RTC) and replication metrics EventThreshold.

                                                                                                                                                                                                                                                                                                                                                                                                                      type RequestCharged

                                                                                                                                                                                                                                                                                                                                                                                                                      type RequestCharged string
                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                      	RequestChargedRequester RequestCharged = "requester"
                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for RequestCharged

                                                                                                                                                                                                                                                                                                                                                                                                                        func (RequestCharged) Values

                                                                                                                                                                                                                                                                                                                                                                                                                        func (RequestCharged) Values() []RequestCharged

                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for RequestCharged. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                          type RequestPayer

                                                                                                                                                                                                                                                                                                                                                                                                                          type RequestPayer string
                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                          	RequestPayerRequester RequestPayer = "requester"
                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for RequestPayer

                                                                                                                                                                                                                                                                                                                                                                                                                            func (RequestPayer) Values

                                                                                                                                                                                                                                                                                                                                                                                                                            func (RequestPayer) Values() []RequestPayer

                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for RequestPayer. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                              type RequestPaymentConfiguration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                Container for Payer.

                                                                                                                                                                                                                                                                                                                                                                                                                                type RestoreRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  Container for restore job parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                  type RestoreRequestType

                                                                                                                                                                                                                                                                                                                                                                                                                                  type RestoreRequestType string
                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                  	RestoreRequestTypeSelect RestoreRequestType = "SELECT"
                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for RestoreRequestType

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (RestoreRequestType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for RestoreRequestType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type RoutingRule

                                                                                                                                                                                                                                                                                                                                                                                                                                      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
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        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 S3KeyFilter

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

                                                                                                                                                                                                                                                                                                                                                                                                                                          A container for object key name prefix and suffix filtering rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type S3Location

                                                                                                                                                                                                                                                                                                                                                                                                                                          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 an Amazon S3 location that will receive the results of the restore request.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type SSEKMS

                                                                                                                                                                                                                                                                                                                                                                                                                                            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
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              type SSES3

                                                                                                                                                                                                                                                                                                                                                                                                                                              type SSES3 struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                Specifies the use of SSE-S3 to encrypt delivered inventory reports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                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 parameters for Select job types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ServerSideEncryption

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for ServerSideEncryption

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (ServerSideEncryption) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for ServerSideEncryption. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ServerSideEncryptionByDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                      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
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 ServerSideEncryptionConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specifies the default server-side encryption configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SourceSelectionCriteria

                                                                                                                                                                                                                                                                                                                                                                                                                                                            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
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 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.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Status SseKmsEncryptedObjectsStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                A container for filter information for the selection of S3 objects encrypted with AWS KMS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SseKmsEncryptedObjectsStatus

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for SseKmsEncryptedObjectsStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (SseKmsEncryptedObjectsStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for SseKmsEncryptedObjectsStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StorageClass string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassStandard           StorageClass = "STANDARD"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassReducedRedundancy  StorageClass = "REDUCED_REDUNDANCY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassStandardIa         StorageClass = "STANDARD_IA"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassOnezoneIa          StorageClass = "ONEZONE_IA"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassIntelligentTiering StorageClass = "INTELLIGENT_TIERING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassGlacier            StorageClass = "GLACIER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassDeepArchive        StorageClass = "DEEP_ARCHIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StorageClassOutposts           StorageClass = "OUTPOSTS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for StorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (StorageClass) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (StorageClass) Values() []StorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for StorageClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StorageClassAnalysis

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 StorageClassAnalysisDataExport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Container for data related to the storage class analysis for an Amazon S3 bucket for export.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StorageClassAnalysisSchemaVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StorageClassAnalysisSchemaVersion string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	StorageClassAnalysisSchemaVersionV1 StorageClassAnalysisSchemaVersion = "V_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for StorageClassAnalysisSchemaVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (StorageClassAnalysisSchemaVersion) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for StorageClassAnalysisSchemaVersion. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Tag struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Name of the object key.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Key *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Value of the tag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Value *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A container of a key value name pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Tagging

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Container for TagSet elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TaggingDirective

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for TaggingDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (TaggingDirective) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for TaggingDirective. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TargetGrant

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Container for granting information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Tier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for Tier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (Tier) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (Tier) Values() []Tier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for Tier. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Tiering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 TopicConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 Transition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 TransitionStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TransitionStorageClass string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransitionStorageClassGlacier            TransitionStorageClass = "GLACIER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransitionStorageClassStandardIa         TransitionStorageClass = "STANDARD_IA"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransitionStorageClassOnezoneIa          TransitionStorageClass = "ONEZONE_IA"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransitionStorageClassIntelligentTiering TransitionStorageClass = "INTELLIGENT_TIERING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransitionStorageClassDeepArchive        TransitionStorageClass = "DEEP_ARCHIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for TransitionStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (TransitionStorageClass) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for TransitionStorageClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Type string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TypeCanonicalUser         Type = "CanonicalUser"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TypeAmazonCustomerByEmail Type = "AmazonCustomerByEmail"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TypeGroup                 Type = "Group"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Type) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Type) Values() []Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for Type. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UnknownUnionMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UnknownUnionMember struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Tag   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Value []byte
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VersioningConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 WebsiteConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specifies website configuration parameters for an Amazon S3 bucket.