func (c *S3) DeleteBucketTagging(input *DeleteBucketTaggingInput) (*DeleteBucketTaggingOutput, error) {
	req, out := c.DeleteBucketTaggingRequest(input)
	err := req.Send()
	return out, err
}
Deletes the tags from the bucket.
package s3
import (
	"bytes"
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"encoding/json"
	"encoding/xml"
	"errors"
	"fmt"
	mapset "github.com/deckarep/golang-set"
	"github.com/ks3sdklib/aws-sdk-go/aws"
	"github.com/ks3sdklib/aws-sdk-go/aws/awserr"
	"hash"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"sort"
	"strings"
	"sync"
	"time"
)
var oprw sync.Mutex
func (c *S3) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) (req *aws.Request, output *AbortMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opAbortMultipartUpload == nil {
		opAbortMultipartUpload = &aws.Operation{
			Name:       "AbortMultipartUpload",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &AbortMultipartUploadInput{}
	}
	req = c.newRequest(opAbortMultipartUpload, 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
}
func (c *S3) AbortMultipartUploadPresignedUrl(input *AbortMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.AbortMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opAbortMultipartUpload *aws.Operation
func (c *S3) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) (req *aws.Request, output *CompleteMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCompleteMultipartUpload == nil {
		opCompleteMultipartUpload = &aws.Operation{
			Name:       "CompleteMultipartUpload",
			HTTPMethod: "POST",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &CompleteMultipartUploadInput{}
	}
	req = c.newRequest(opCompleteMultipartUpload, 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
}
func (c *S3) CompleteMultipartUploadPresignedUrl(input *CompleteMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CompleteMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCompleteMultipartUpload *aws.Operation
func (c *S3) CopyObjectRequest(input *CopyObjectInput) (req *aws.Request, output *CopyObjectOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCopyObject == nil {
		opCopyObject = &aws.Operation{
			Name:       "CopyObject",
			HTTPMethod: "PUT",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &CopyObjectInput{}
	}
	req = c.newRequest(opCopyObject, 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
}
func (c *S3) CopyObjectPresignedUrl(input *CopyObjectInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CopyObjectRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCopyObject *aws.Operation
func (c *S3) CreateBucketRequest(input *CreateBucketInput) (req *aws.Request, output *CreateBucketOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCreateBucket == nil {
		opCreateBucket = &aws.Operation{
			Name:       "CreateBucket",
			HTTPMethod: "PUT",
			HTTPPath:   "/{Bucket}",
		}
	}
	if input == nil {
		input = &CreateBucketInput{}
	}
	req = c.newRequest(opCreateBucket, 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
}
func (c *S3) CreateBucketPresignedUrl(input *CreateBucketInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CreateBucketRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCreateBucket *aws.Operation
func (c *S3) CreateMultipartUploadRequest(input *CreateMultipartUploadInput) (req *aws.Request, output *CreateMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCreateMultipartUpload == nil {
		opCreateMultipartUpload = &aws.Operation{
			Name:       "CreateMultipartUpload",
			HTTPMethod: "POST",
			HTTPPath:   "/{Bucket}/{Key+}?uploads",
		}
	}
	if input == nil {
		input = &CreateMultipartUploadInput{}
	}
	req = c.newRequest(opCreateMultipartUpload, 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
}
func (c *S3) CreateMultipartUploadPresignedUrl(input *CreateMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CreateMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCreateMultipartUpload *aws.Operation
func (c *S3) DeleteBucketRequest(input *DeleteBucketInput) (req *aws.Request, output *DeleteBucketOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucket == nil {
		opDeleteBucket = &aws.Operation{
			Name:       "DeleteBucket",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}",
		}
	}
	if input == nil {
		input = &DeleteBucketInput{}
	}
	req = c.newRequest(opDeleteBucket, input, output)
	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
}
func (c *S3) DeleteBucketPresignedUrl(input *DeleteBucketInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucket *aws.Operation
func (c *S3) DeleteBucketCORSRequest(input *DeleteBucketCORSInput) (req *aws.Request, output *DeleteBucketCORSOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketCORS == nil {
		opDeleteBucketCORS = &aws.Operation{
			Name:       "DeleteBucketCors",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?cors",
		}
	}
	if input == nil {
		input = &DeleteBucketCORSInput{}
	}
	req = c.newRequest(opDeleteBucketCORS, input, output)
	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
}
func (c *S3) DeleteBucketCORSPresignedUrl(input *DeleteBucketCORSInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketCORSRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketCORS *aws.Operation
func (c *S3) DeleteBucketLifecycleRequest(input *DeleteBucketLifecycleInput) (req *aws.Request, output *DeleteBucketLifecycleOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketLifecycle == nil {
		opDeleteBucketLifecycle = &aws.Operation{
			Name:       "DeleteBucketLifecycle",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?lifecycle",
		}
	}
	if input == nil {
		input = &DeleteBucketLifecycleInput{}
	}
	req = c.newRequest(opDeleteBucketLifecycle, input, output)
	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
}
func (c *S3) DeleteBucketLifecyclePresignedUrl(input *DeleteBucketLifecycleInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketLifecycleRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketLifecycle *aws.Operation
func (c *S3) DeleteBucketPolicyRequest(input *DeleteBucketPolicyInput) (req *aws.Request, output *DeleteBucketPolicyOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketPolicy == nil {
		opDeleteBucketPolicy = &aws.Operation{
			Name:       "DeleteBucketPolicy",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?policy",
		}
	}
	if input == nil {
		input = &DeleteBucketPolicyInput{}
	}
	req = c.newRequest(opDeleteBucketPolicy, input, output)
	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
}
func (c *S3) DeleteBucketPolicyPresignedUrl(input *DeleteBucketPolicyInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketPolicyRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketPolicy *aws.Operation
func (c *S3) DeleteBucketReplicationRequest(input *DeleteBucketReplicationInput) (req *aws.Request, output *DeleteBucketReplicationOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketReplication == nil {
		opDeleteBucketReplication = &aws.Operation{
			Name:       "DeleteBucketReplication",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?replication",
		}
	}
	if input == nil {
		input = &DeleteBucketReplicationInput{}
	}
	req = c.newRequest(opDeleteBucketReplication, input, output)
	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
}
func (c *S3) DeleteBucketReplicationPresignedUrl(input *DeleteBucketReplicationInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketReplicationRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketReplication *aws.Operation
func (c *S3) DeleteBucketTaggingRequest(input *DeleteBucketTaggingInput) (req *aws.Request, output *DeleteBucketTaggingOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketTagging == nil {
		opDeleteBucketTagging = &aws.Operation{
			Name:       "DeleteBucketTagging",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?tagging",
		}
	}
	if input == nil {
		input = &DeleteBucketTaggingInput{}
	}
	req = c.newRequest(opDeleteBucketTagging, input, output)
	output = &DeleteBucketTaggingOutput{}
	req.Data = output
	return
}