func (c *S3) DeleteBucketWebsiteRequest(input *DeleteBucketWebsiteInput) (req *request.Request, output *DeleteBucketWebsiteOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketWebsite,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?website",
	}
	if input == nil {
		input = &DeleteBucketWebsiteInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketWebsiteOutput{}
	req.Data = output
	return
}
DeleteBucketWebsiteRequest generates a "aws/request.Request" representing the
client's request for the DeleteBucketWebsite operation. The "output" return
value can be used to capture response data after the request's "Send" method
is called.

See DeleteBucketWebsite for usage and error information.

Creating a request object using this method should be used when you want to inject
custom logic into the request's lifecycle using a custom handler, or if you want to
access properties on the request object before or after sending the request. If
you just want the service response, call the DeleteBucketWebsite method directly
instead.

Note: You must call the "Send" method on the returned request object in order
to execute the request.

// Example sending a request using the DeleteBucketWebsiteRequest method.
req, resp := client.DeleteBucketWebsiteRequest(params)

err := req.Send()
if err == nil { // resp is now filled
fmt.Println(resp)
}
package s3
import (
	"fmt"
	"io"
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/private/protocol"
	"github.com/aws/aws-sdk-go/private/protocol/restxml"
)
const opAbortMultipartUpload = "AbortMultipartUpload"
func (c *S3) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) (req *request.Request, output *AbortMultipartUploadOutput) {
	op := &request.Operation{
		Name:       opAbortMultipartUpload,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}/{Key+}",
	}
	if input == nil {
		input = &AbortMultipartUploadInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AbortMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) AbortMultipartUpload(input *AbortMultipartUploadInput) (*AbortMultipartUploadOutput, error) {
	req, out := c.AbortMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
const opCompleteMultipartUpload = "CompleteMultipartUpload"
func (c *S3) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) (req *request.Request, output *CompleteMultipartUploadOutput) {
	op := &request.Operation{
		Name:       opCompleteMultipartUpload,
		HTTPMethod: "POST",
		HTTPPath:   "/{Bucket}/{Key+}",
	}
	if input == nil {
		input = &CompleteMultipartUploadInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CompleteMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) CompleteMultipartUpload(input *CompleteMultipartUploadInput) (*CompleteMultipartUploadOutput, error) {
	req, out := c.CompleteMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
const opCopyObject = "CopyObject"
func (c *S3) CopyObjectRequest(input *CopyObjectInput) (req *request.Request, output *CopyObjectOutput) {
	op := &request.Operation{
		Name:       opCopyObject,
		HTTPMethod: "PUT",
		HTTPPath:   "/{Bucket}/{Key+}",
	}
	if input == nil {
		input = &CopyObjectInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CopyObjectOutput{}
	req.Data = output
	return
}
func (c *S3) CopyObject(input *CopyObjectInput) (*CopyObjectOutput, error) {
	req, out := c.CopyObjectRequest(input)
	err := req.Send()
	return out, err
}
const opCreateBucket = "CreateBucket"
func (c *S3) CreateBucketRequest(input *CreateBucketInput) (req *request.Request, output *CreateBucketOutput) {
	op := &request.Operation{
		Name:       opCreateBucket,
		HTTPMethod: "PUT",
		HTTPPath:   "/{Bucket}",
	}
	if input == nil {
		input = &CreateBucketInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateBucketOutput{}
	req.Data = output
	return
}
func (c *S3) CreateBucket(input *CreateBucketInput) (*CreateBucketOutput, error) {
	req, out := c.CreateBucketRequest(input)
	err := req.Send()
	return out, err
}
const opCreateMultipartUpload = "CreateMultipartUpload"
func (c *S3) CreateMultipartUploadRequest(input *CreateMultipartUploadInput) (req *request.Request, output *CreateMultipartUploadOutput) {
	op := &request.Operation{
		Name:       opCreateMultipartUpload,
		HTTPMethod: "POST",
		HTTPPath:   "/{Bucket}/{Key+}?uploads",
	}
	if input == nil {
		input = &CreateMultipartUploadInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) CreateMultipartUpload(input *CreateMultipartUploadInput) (*CreateMultipartUploadOutput, error) {
	req, out := c.CreateMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucket = "DeleteBucket"
func (c *S3) DeleteBucketRequest(input *DeleteBucketInput) (req *request.Request, output *DeleteBucketOutput) {
	op := &request.Operation{
		Name:       opDeleteBucket,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}",
	}
	if input == nil {
		input = &DeleteBucketInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucket(input *DeleteBucketInput) (*DeleteBucketOutput, error) {
	req, out := c.DeleteBucketRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketAnalyticsConfiguration = "DeleteBucketAnalyticsConfiguration"
func (c *S3) DeleteBucketAnalyticsConfigurationRequest(input *DeleteBucketAnalyticsConfigurationInput) (req *request.Request, output *DeleteBucketAnalyticsConfigurationOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketAnalyticsConfiguration,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?analytics",
	}
	if input == nil {
		input = &DeleteBucketAnalyticsConfigurationInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketAnalyticsConfigurationOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketAnalyticsConfiguration(input *DeleteBucketAnalyticsConfigurationInput) (*DeleteBucketAnalyticsConfigurationOutput, error) {
	req, out := c.DeleteBucketAnalyticsConfigurationRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketCors = "DeleteBucketCors"
func (c *S3) DeleteBucketCorsRequest(input *DeleteBucketCorsInput) (req *request.Request, output *DeleteBucketCorsOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketCors,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?cors",
	}
	if input == nil {
		input = &DeleteBucketCorsInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketCorsOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketCors(input *DeleteBucketCorsInput) (*DeleteBucketCorsOutput, error) {
	req, out := c.DeleteBucketCorsRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketInventoryConfiguration = "DeleteBucketInventoryConfiguration"
func (c *S3) DeleteBucketInventoryConfigurationRequest(input *DeleteBucketInventoryConfigurationInput) (req *request.Request, output *DeleteBucketInventoryConfigurationOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketInventoryConfiguration,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?inventory",
	}
	if input == nil {
		input = &DeleteBucketInventoryConfigurationInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketInventoryConfigurationOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketInventoryConfiguration(input *DeleteBucketInventoryConfigurationInput) (*DeleteBucketInventoryConfigurationOutput, error) {
	req, out := c.DeleteBucketInventoryConfigurationRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketLifecycle = "DeleteBucketLifecycle"
func (c *S3) DeleteBucketLifecycleRequest(input *DeleteBucketLifecycleInput) (req *request.Request, output *DeleteBucketLifecycleOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketLifecycle,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?lifecycle",
	}
	if input == nil {
		input = &DeleteBucketLifecycleInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketLifecycleOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketLifecycle(input *DeleteBucketLifecycleInput) (*DeleteBucketLifecycleOutput, error) {
	req, out := c.DeleteBucketLifecycleRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketMetricsConfiguration = "DeleteBucketMetricsConfiguration"
func (c *S3) DeleteBucketMetricsConfigurationRequest(input *DeleteBucketMetricsConfigurationInput) (req *request.Request, output *DeleteBucketMetricsConfigurationOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketMetricsConfiguration,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?metrics",
	}
	if input == nil {
		input = &DeleteBucketMetricsConfigurationInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketMetricsConfigurationOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketMetricsConfiguration(input *DeleteBucketMetricsConfigurationInput) (*DeleteBucketMetricsConfigurationOutput, error) {
	req, out := c.DeleteBucketMetricsConfigurationRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketPolicy = "DeleteBucketPolicy"
func (c *S3) DeleteBucketPolicyRequest(input *DeleteBucketPolicyInput) (req *request.Request, output *DeleteBucketPolicyOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketPolicy,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?policy",
	}
	if input == nil {
		input = &DeleteBucketPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketPolicyOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketPolicy(input *DeleteBucketPolicyInput) (*DeleteBucketPolicyOutput, error) {
	req, out := c.DeleteBucketPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketReplication = "DeleteBucketReplication"
func (c *S3) DeleteBucketReplicationRequest(input *DeleteBucketReplicationInput) (req *request.Request, output *DeleteBucketReplicationOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketReplication,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?replication",
	}
	if input == nil {
		input = &DeleteBucketReplicationInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketReplicationOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketReplication(input *DeleteBucketReplicationInput) (*DeleteBucketReplicationOutput, error) {
	req, out := c.DeleteBucketReplicationRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketTagging = "DeleteBucketTagging"
func (c *S3) DeleteBucketTaggingRequest(input *DeleteBucketTaggingInput) (req *request.Request, output *DeleteBucketTaggingOutput) {
	op := &request.Operation{
		Name:       opDeleteBucketTagging,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{Bucket}?tagging",
	}
	if input == nil {
		input = &DeleteBucketTaggingInput{}
	}
	req = c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output = &DeleteBucketTaggingOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketTagging(input *DeleteBucketTaggingInput) (*DeleteBucketTaggingOutput, error) {
	req, out := c.DeleteBucketTaggingRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteBucketWebsite = "DeleteBucketWebsite"